home *** CD-ROM | disk | FTP | other *** search
/ Aminet 1 (Walnut Creek) / Aminet - June 1993 [Walnut Creek].iso / usenet / sources / volume89 / unix / shar.1 < prev    next >
Text File  |  1989-01-30  |  72KB  |  1,612 lines
  1. Path: xanth!ukma!mailrus!ulowell!page
  2. From: page@swan.ulowell.edu (Bob Page)
  3. Newsgroups: comp.sources.amiga
  4. Subject: v89i004:  shar - shell archiver
  5. Message-ID: <11466@swan.ulowell.edu>
  6. Date: 30 Jan 89 21:42:44 GMT
  7. Organization: University of Lowell, Computer Science Dept.
  8. Lines: 1601
  9. Approved: page@swan.ulowell.edu
  10.  
  11. Submitted-by: jc3b21!fgd3@uunet.UU.NET (Fabbian G. Dufoe)
  12. Posting-number: Volume 89, Issue 4
  13. Archive-name: unix/shar.1
  14.  
  15. [uuencoded executables included.  ..Bob]
  16.  
  17. #    This is a shell archive.
  18. #    Remove everything above and including the cut line.
  19. #    Then run the rest of the file through sh.
  20. #----cut here-----cut here-----cut here-----cut here----#
  21. #!/bin/sh
  22. # shar:    Shell Archiver
  23. #    Run the following text with /bin/sh to create:
  24. #    Fatal.c
  25. #    Fgetline.c
  26. #    Gettoken.c
  27. #    Makefile
  28. #    Parse.c
  29. #    Sh.c
  30. #    Sh.doc
  31. #    Sh.lnk
  32. #    Sh.uu
  33. #    Shar.c
  34. #    Shar.uu
  35. #    Token.h
  36. # This archive created: Mon Jan 30 16:39:01 1989
  37. cat << \SHAR_EOF > Fatal.c
  38. /* Fatal.c
  39.  
  40.    Copyright (c) 1987 by F. G. Dufoe, III
  41.    All rights reserved.
  42.  
  43.    Permission is granted to redistribute this program provided the source
  44.    code is included in the distribution and this copyright notice is
  45.    unchanged.
  46.  
  47. */
  48.  
  49.  
  50. #include <stdio.h>
  51. #ifdef AMIGA
  52. #include <error.h>
  53. #include <exec/types.h>
  54. #else
  55. #include <errno.h>
  56. #include <ctype.h>
  57. extern int sys_nerr;
  58. extern char *sys_errlist[];
  59. #endif
  60.  
  61.  
  62. void
  63. fatal(string)
  64.    /* This function prints an error message passed by the calling program
  65.       and exits with an error code. */
  66. char *string;
  67. {
  68.    extern int errno;
  69.       /* This global variable is used to communicate error codes. */
  70.  
  71.    fprintf(stderr, "%s\n", string);
  72.       /* Print the error message passed by the calling program on standard
  73.          error. */
  74.    if (errno > 0 && errno < sys_nerr)
  75.       fprintf(stderr, "\t%d: %s\n", errno, sys_errlist[errno]);
  76.          /* If the error number is in the system error list print it and its
  77.             explanation on standard error. */
  78.    exit(errno);
  79.       /* Terminate the program and pass an error code back to the parent
  80.          program. */
  81. }
  82. SHAR_EOF
  83. cat << \SHAR_EOF > Fgetline.c
  84. /* Fgetline.c
  85.  
  86.    Copyright (c) by Fabbian G. Dufoe, III
  87.    All rights reserved.
  88.  
  89.    Permission is granted to redistribute this program provided the source
  90.    code is included in the distribution and this copyright notice is
  91.    unchanged.
  92.  
  93. */
  94.  
  95.  
  96. #include <stdio.h>
  97. #ifdef AMIGA
  98. #include <error.h>
  99. #include <exec/types.h>
  100. #else
  101. #include <errno.h>
  102. #include <ctype.h>
  103. extern int sys_nerr;
  104. extern char *sys_errlist[];
  105. #endif
  106.  
  107.  
  108. #define AVGLINE 512
  109.    /* This is the amount of space which will be allocated initially for
  110.       the buffer into which lines read from the file will be placed. */
  111. #define MARGIN 10
  112.    /* When we get within MARGIN characters of the end of the buffer we
  113.       will try to get more memory before proceeding. */
  114.  
  115.  
  116. char *
  117. fgetline(ifile)
  118.    /* This function gets the next line of text from a file.  The calling
  119.       program passes it a FILE pointer to identify the file.  Fgetline()
  120.       returns a pointer to a null-terminated character string containing the
  121.       line from that file if it successfully read any characters.  It
  122.       returns a NULL pointer if an error occurs or if it encountered end of
  123.       file.  The calling program must examine the external variable errno
  124.       to determine which is the case.  If fgetline() encountered end of file
  125.       errno will be zero. */
  126. FILE *ifile;
  127.    /* This is a file pointer for the file to be read. */
  128. {
  129.    int c;
  130.       /* This is the character read from the file. */
  131.    extern int errno;
  132.       /* This global variable is used to communicate error codes. */
  133.    int i;
  134.       /* This is a counter that is incremented for each character placed
  135.          in the buffer. */
  136.    static int length = AVGLINE;
  137.       /* This is the length of the character buffer that has been
  138.          allocated. */
  139.    static char *line = NULL;
  140.       /* This is the address of the character string containing the line
  141.          read from the file. */
  142.    char *newline;
  143.       /* This is a temporary pointer used when more memory has to be
  144.          allocated.  Realloc() returns a NULL pointer if it fails and we
  145.          don't want to lose track of the characters we have already
  146.          collected. */
  147.  
  148.  
  149.    if (line == NULL)
  150.       /* If the line buffer hasn't been allocated yet do it now. */
  151.       if ((line = (char *)malloc(length)) == NULL)
  152.          /* If malloc() returns a NULL pointer the memory couldn't be
  153.             allocated.  Return a NULL pointer.  The calling program
  154.             can look at errno for the reason. */
  155.          return(NULL);
  156.  
  157.    for (i = 0; (c = fgetc(ifile)) != EOF && c != '\n'; i++)
  158.       /* As long as we don't hit EOF or a newline keep collecting
  159.          characters. */
  160.    {
  161.       *(line + i) = c;
  162.       if (i > length - MARGIN)
  163.          /* If we are within MARGIN characters of the end of the
  164.             buffer try to allocate more memory. */
  165.       {
  166.          newline = (char *)realloc(line, length + AVGLINE);
  167.          if (newline == NULL)
  168.             /* If realloc() failed we try to salvage what we have
  169.                already collected. */
  170.          {
  171.             *(line + ++i) = '\0';
  172.                /* Tack on a null-terminator. */
  173.             return(line);
  174.                /* Return the pointer to the string we have
  175.                   collected so far. */
  176.          }
  177.          length += AVGLINE;
  178.             /* The buffer is longer now, so we'll update our record
  179.                of its length. */
  180.          line = newline;
  181.             /* We got the additional space we asked for so we change
  182.                the pointer to refer to the new buffer. */
  183.       }
  184.    }
  185.  
  186.    if (c == '\n')
  187.       /* If we came to a newline character we are at the end of the
  188.          line.  Add the newline to the end of the buffer. */
  189.       *(line + i++) = c;
  190.  
  191.    if (c == EOF && i == 0)
  192.       /* If we are at end of file and there are no characters in the
  193.          buffer we can free the buffer's memory, set the pointer to
  194.          NULL, and return. */
  195.    {
  196.       free(line);
  197.       line = NULL;
  198.       errno = 0;
  199.       return(NULL);
  200.    }
  201.  
  202.    *(line + i) = '\0';
  203.       /* Terminate the string with a null character. */
  204.  
  205.    return(line);
  206.       /* Return the pointer to the calling program. */
  207. }
  208. SHAR_EOF
  209. cat << \SHAR_EOF > Gettoken.c
  210. /* Gettoken.c
  211.  
  212.    Copyright (c) 1987 by F. G. Dufoe, III
  213.    All rights reserved.
  214.  
  215.    Permission is granted to redistribute this program provided the source
  216.    code is included in the distribution and this copyright notice is
  217.    unchanged.
  218.  
  219.    Revision summary:
  220.    1 August 1987: Added case to handle word beginning with "\".
  221.    3 August 1988: Added case to handle single quoted strings.
  222.  
  223. */
  224.  
  225. #include <string.h>
  226. #include "Token.h"
  227.  
  228.  
  229. TOKEN
  230. gettoken(line, word)
  231.    /* This function gets the next token from a line of text.  The calling
  232.       program passes it two character pointers.  The first points to the
  233.       buffer containing the line of text to be parsed.  The second points to
  234.       a buffer in which the function is to place the text of the token.  The
  235.       function returns the token type (as defined in Token.h). */
  236. char *line;
  237.    /* This points to the line of text to be parsed. */
  238. char *word;
  239.    /* This is where the function can store the text of the token. */
  240. {
  241.    int c;
  242.       /* This is the current character read from the line. */
  243.  
  244.    static int il = 0;
  245.       /* This is the index for line[]. */
  246.  
  247.    int iw = 0;
  248.       /* This is the index for word[]. */
  249.  
  250.    enum
  251.    {
  252.       LT,       /* One "<" found, look for another. */
  253.       NEUTRAL,  /* Look for first character of token. */
  254.       INQUOTE,  /* Open single quote found, accumulate until closing single
  255.                    quote found. */ /* 3 August 1988 */
  256.       INQUOTE2, /* Open double quote found, accumulate until closing double
  257.                    quote found. */ /* 3 August 1988 */
  258.       INWORD    /* Unrecognized character, accumulate until word ends. */
  259.    } state = NEUTRAL;
  260.  
  261.    while ((c = line[il++]) != '\0')
  262.       /* We are prepared to read the entire line.  If we identify a token
  263.          before we reach the end of the line we'll return early. */
  264.    {
  265.       switch (state)
  266.       {
  267.          case NEUTRAL:
  268.             switch (c)
  269.             {
  270.                case '>':
  271.                   word[iw++] = c;
  272.                   word[iw] = '\0';
  273.                   return(T_GT);
  274.                      /* We recognize the greater than sign immediately, so
  275.                         we put it in the buffer and return. */
  276.                case '<':
  277.                   state = LT;
  278.                   word[iw++] = c;
  279.                   continue;
  280.                      /* We can't identify this token until we know whether
  281.                         the next character is another "<", so we just save
  282.                         it and look at the next character.  The state change
  283.                         "remembers" that we saw a "<". */
  284.                case ' ':
  285.                case '\n':
  286.                case '\t':
  287.                   continue;
  288.                      /* We just ignore any whitespace characters. */
  289.                case '\'': /* 3 August 1988 */
  290.                   state = INQUOTE; /* 3 August 1988 */
  291.                   continue; /* 3 August 1988 */
  292.                      /* INQUOTE works just like INQUOTE2 except that it
  293.                         requires a closing single quote instead of a double
  294.                         quote to terminate the accumulation of characters.
  295.                         */ /* 3 August 1988 */
  296.                case '"':
  297.                   state = INQUOTE2; /* 3 August 1988 */
  298.                   continue;
  299.                      /* Inside a quoted string we will accumulate all
  300.                         characters, including whitespace characters.  But we
  301.                         don't consider the quotation marks as part of the
  302.                         string.  We change state to accumulate characters
  303.                         differently. */
  304.                case '\\':                    /* 1 August 1987 */
  305.                   state = INWORD;            /* 1 August 1987 */
  306.                   word[iw++] = line[il++];   /* 1 August 1987 */
  307.                   continue;                  /* 1 August 1987 */
  308.                      /* We recognize the backslash as an escape character.
  309.                         If we find one at the beginning of a token we want
  310.                         to get the next character without interpreting it.
  311.                         It will become part of a word. */
  312.                default:
  313.                   state = INWORD;
  314.                   word[iw++] = c;
  315.                   continue;
  316.                      /* Any character not listed above is the beginning of a
  317.                         word.  We will want to accumulate it and those that
  318.                         follow until the word ends. */
  319.             }
  320.          case LT:
  321.             if (c == '<')
  322.             {
  323.                word[iw++] = c;
  324.                word[iw] = '\0';
  325.                return(T_LTLT);
  326.                   /* We found the second "<", so we put it in the buffer and
  327.                      return. */
  328.             }
  329.             word[iw] = '\0';
  330.             il--;
  331.             return(T_WORD);
  332.                /* The second character wasn't "<", so we will return the
  333.                   single "<" as a word.  We will want to look at the second
  334.                   character again, so we decrement il. */
  335.          case INQUOTE: /* 3 August 1988 */
  336.             switch (c) /* 3 August 1988 */
  337.             { /* 3 August 1988 */
  338.                case '\\': /* 3 August 1988 */
  339.                   word[iw++] = line[il++]; /* 3 August 1988 */
  340.                   continue; /* 3 August 1988 */
  341.                      /* If we find a "\" we want to include the next
  342.                         character in our string instead of acting on it. */
  343.                      /* 3 August 1988 */
  344.                case '\'': /* 3 August 1988 */
  345.                   word[iw] = '\0'; /* 3 August 1988 */
  346.                   return(T_WORD); /* 3 August 1988 */
  347.                      /* We are at the end of the quoted string.  We
  348.                         terminate the string with a null and return.  We
  349.                         don't include the quotation mark in the string. */
  350.                      /* 3 August 1988 */
  351.                default: /* 3 August 1988 */
  352.                   word[iw++] = c; /* 3 August 1988 */
  353.                   continue; /* 3 August 1988 */
  354.                      /* This isn't one of the special characters dealt with
  355.                         above, so we just accumulate it into our string. */
  356.             } /* 3 August 1988 */
  357.          case INQUOTE2: /* 3 August 1988 */
  358.             switch (c)
  359.             {
  360.                case '\\':
  361.                   word[iw++] = line[il++];
  362.                   continue;
  363.                      /* If we find a "\" we want to include the next
  364.                         character in our string instead of acting on it. */
  365.                case '"':
  366.                   word[iw] = '\0';
  367.                   return(T_WORD);
  368.                      /* We are at the end of the quoted string.  We
  369.                         terminate the string with a null and return.  We
  370.                         don't include the quotation mark in the string. */
  371.                default:
  372.                   word[iw++] = c;
  373.                   continue;
  374.                      /* This isn't one of the special characters dealt with
  375.                         above, so we just accumulate it into our string. */
  376.             }
  377.          case INWORD:
  378.             switch (c)
  379.             {
  380.                case ' ':
  381.                case '\t':
  382.                case '\n':
  383.                case '<':
  384.                case '>':
  385.                case '"':
  386.                   il--;
  387.                      /* Decrement the pointer so we will look at this
  388.                         character again. */
  389.                   word[iw] = '\0';
  390.                      /* Add a null terminator to the token's text string. */
  391.                   if (strcmp(word, "cat") == 0)
  392.                      return(T_CAT);
  393.                         /* There are two special cases of word tokens, the
  394.                            "cat" and "echo" commands. */
  395.                   if (strcmp(word, "echo") == 0)
  396.                      return(T_ECHO);
  397.                   return(T_WORD);
  398.                default:
  399.                   word[iw++] = c;
  400.                      /* Add the character to the string. */
  401.                   continue;
  402.                      /* Get the next character and repeat the cycle. */
  403.             }
  404.       }
  405.    }
  406.    il = 0;
  407.       /* Since we have finished with the current line we reset the index so
  408.          we will start examining the next line at the beginning. */
  409.    return(T_NL);
  410.       /* This is how we tell the calling program we have reached the end of
  411.          the line. */
  412. }
  413. SHAR_EOF
  414. cat << \SHAR_EOF > Makefile
  415. lc -M Sh Fatal Fgetline Gettoken Parse
  416. blink with Sh.lnk
  417. SHAR_EOF
  418. cat << \SHAR_EOF > Parse.c
  419. /* Parse.c
  420.  
  421.    Copyright (c) 1987 by F. G. Dufoe, III
  422.    All rights reserved.
  423.  
  424.    Permission is granted to redistribute this program provided the source
  425.    code is included in the distribution and this copyright notice is
  426.    unchanged.
  427.  
  428.    Revision summary:
  429.    4 August 1987: Moved text pointer initialization code to execute on every
  430.                   invocation.
  431.    19 December 1988: Changed word to a dynamically allocated array of char
  432.                      to prevent failures caused by extremely long words.
  433.                      Added code to free previously allocated token
  434.                      structures if a fatal error occurs.
  435.  
  436. */
  437.  
  438. #include <stdlib.h>
  439. #include <string.h>
  440. #include "Token.h"
  441.  
  442.  
  443. struct Token *
  444. parse(line, text)
  445.    /* This function parses a line of text.  The calling program passes it
  446.       two character pointers.  The first points to the null-terminated
  447.       string containing the line of text to be parsed.  The second points to
  448.       a buffer the calling program has defined for storing the text of the
  449.       tokens parse() gets.  Parse() returns a pointer to a linked list of
  450.       Token structures (Token structures are defined in Token.h). */
  451. char *line;
  452.    /* This points to the line of text to be parsed.  If it is NULL the
  453.       calling program is through with the list of Token structures and their
  454.       memory can be freed. */
  455. char *text;
  456.    /* This points to the area where token text will be stored.  Text from
  457.       all the tokens will be stored here, so it must be as long as the line
  458.       to be parsed. */
  459. {
  460.    struct Token *current;
  461.       /* This points to the current Token structure. */
  462.  
  463.    static struct Token *first = NULL;
  464.       /* This points to the beginning of the list of Token structures. */
  465.  
  466.    void freetokens(struct Token *);
  467.       /* This function walks the list of Token structures and frees their
  468.          memory. */
  469.  
  470.    TOKEN gettoken(char *, char *);
  471.       /* This function gets the next token from a character string. */
  472.  
  473.    TOKEN type;
  474.       /* This is the token type returned by gettoken(). */
  475.  
  476.    char *word; /* 19 December 1988 */
  477.       /* This array will be used by gettoken() to store the text of the
  478.          tokens it gets.  Only one token at a time will be stored here. */
  479.  
  480.  
  481.    if (line == NULL)
  482.       /* If the calling program passes a NULL pointer we'll free the memory
  483.          allocated for Token structures and return a NULL pointer. */
  484.    {
  485.       freetokens(first);
  486.       return(NULL);
  487.    }
  488.  
  489.    if (first == NULL)
  490.       /* No memory for Token structures has been allocated yet.  Allocate
  491.          the first one. */
  492.    {
  493.       if ((first = (struct Token *)malloc(sizeof(struct Token))) == NULL)
  494.          fatal("Parse: Could not allocate Token structure.");
  495.          /* If we can't allocate memory for a Token structure we can't
  496.             continue.  Notify the user and terminate. */
  497.       first->next = NULL;
  498.          /* Until we have allocated another Token structure this one is the
  499.             end of the list. */
  500.    }
  501.  
  502.    current = first;
  503.       /* We'll start by using the first Token structure we allocated. */
  504.    current->text = text; /* 4 August 1987 */
  505.       /* We'll use the text buffer supplied by the calling program to
  506.          store the token text. */
  507.    if ((word = (char *)malloc(strlen(line))) == NULL) /* 19 December 1988 */
  508.       /* Allocate enough space to hold the entire line, in case the line
  509.          contains only one word. */ /* 19 December 1988 */
  510.    { /* 19 December 1988
  511.       freetokens(first); /* 19 December 1988 */
  512.       fatal("Parse: Could not allocate word array."); /* 19 December 1988 */
  513.    } /* 19 December 1988 */
  514.  
  515.    while ((type = gettoken(line, word)) != T_NL)
  516.       /* Until we get to the end of the line, keep asking for the next
  517.          token. */
  518.    {
  519.       current->type = type;
  520.          /* Save the type which gettoken() returned. */
  521.       strcpy (current->text, word);
  522.          /* Save the text which gettoken() returned. */
  523.       if (current->next == NULL)
  524.          /* If we don't already have another Token structure allocated let's
  525.             allocate one now to use for the next token. */
  526.       {
  527.          if ((current->next = (struct Token *)
  528.                               malloc(sizeof(struct Token))) == NULL)
  529.          { /* 19 December 1988 */
  530.             free(word); /* 19 December 1988 */
  531.             freetokens(first); /* 19 December 1988 */
  532.             fatal("Parse: Could not allocate Token structure.");
  533.                /* If we couldn't allocate the next Token structure we can't
  534.                   continue.  Notify the user and terminate. */
  535.          } /* 19 December 1988 */
  536.          current->next->next = NULL;
  537.             /* Make the new structure the one at the end of the list by
  538.                setting its next pointer to NULL. */
  539.       }
  540.       current->next->text = current->text + strlen(word) + 1;
  541.          /* Advance the text pointer to the next available address in the
  542.             calling program's text buffer. */
  543.       current = current->next;
  544.          /* Make the next structure the current one. */
  545.    }
  546.    current->type = type;
  547.    *(current->text) = 0;
  548.    if (current->next != NULL)
  549.       /* If we have some unused Token structures in our list let's free them
  550.          now.  Since we use the same Token structure list over for
  551.          subsequent lines this can happen if a short line follows a long
  552.          one. */
  553.    {
  554.       freetokens(current->next);
  555.       current->next = NULL;
  556.    }
  557.    free(word); /* 19 December 1988 */
  558.    return(first);
  559. }
  560.  
  561.  
  562. void
  563. freetokens(head)
  564.      /* This function walks the list of Token structures and frees the
  565.         memory allocated for the structures. */
  566. struct Token *head;
  567. {
  568.      if (head->next != NULL)
  569.           freetokens(head->next);
  570.      free((char *)head);
  571. }
  572. SHAR_EOF
  573. cat << \SHAR_EOF > Sh.c
  574. /* Sh.c
  575.  
  576.    Copyright (c) 1987 by F. G. Dufoe, III
  577.    All rights reserved.
  578.  
  579.    Permission is granted to redistribute this program provided the source
  580.    code is included in the distribution and this copyright notice is
  581.    unchanged.
  582.  
  583. */
  584.  
  585.  
  586. #include <stdio.h>
  587. #include <stdlib.h>
  588. #include "Token.h"
  589.  
  590.  
  591. main(argc, argv)
  592.    /* This program unpacks a shell archive created by Shar.  If the user
  593.       typed more than one file name or typed a question mark on the command
  594.       line the program prints an error message and terminates.  Otherwise it
  595.       tries to open the specified file for input.  If it cannot open the
  596.       file it prints an error message and terminates. */
  597. int argc;
  598.    /* This is the number of arguments on the command line. */
  599. char **argv;
  600.    /* This points to a character array containing the argument values. */
  601. {
  602.    char ehd[512];
  603.       /* When we find a token which identifies the end of the "here
  604.          document" we'll store it here. */
  605.    int ehdl;
  606.       /* This is the length of the "end here document" string. */
  607.    char errmsg[256];
  608.       /* We'll use this character array to put together error messages which
  609.          contain variables. */
  610.    char *fgetline(FILE *);
  611.       /* This function gets the next line of text from a file. */
  612.    FILE *ifile;
  613.       /* This FILE pointer identifies the input file we want to read with
  614.          fgetline(). */
  615.    char *line;
  616.       /* This is the pointer to the line of text returned by fgetline(). */
  617.    int linelen;
  618.       /* This is the length of the line returned by fgetline(). */
  619.    enum
  620.    {
  621.       NEUTRAL,
  622.       COPY
  623.    } mode = NEUTRAL;
  624.       /* In NEUTRAL mode the program reads through the file looking for
  625.          "echo" and "cat" commands and their arguments.  In COPY mode it
  626.          writes each line to an output file until it encounters the text
  627.          string marking the end of the "here document". */
  628.    FILE *ofile;
  629.       /* This file pointer identifies the current output file. */
  630.    struct Token *parse(char *, char *);
  631.       /* This function parses a line of text. */
  632.    TOKEN state;
  633.       /* State is the token type of the previous token. */
  634.    char *text = NULL;
  635.       /* This points to the text buffer where the token text will be
  636.          stored. */
  637.    int textlen = 0;
  638.       /* This is the length of the buffer allocated for token text. */
  639.    struct Token *token;
  640.       /* This points to the list of Token structures returned by parse(). */
  641.  
  642.    if ((argc != 2) || (argv[1][0] == '?'))
  643.       fatal("Usage: Sh file.");
  644.       /* If the user requested one or provided the wrong number of arguments
  645.          print a usage message and terminate. */
  646.  
  647.    if ((ifile = fopen(*(argv + 1), "r")) == NULL)
  648.    {
  649.       sprintf(errmsg, "Sh: Can't open %s for input.", *(argv + 1));
  650.       fatal(errmsg);
  651.    }
  652.       /* If we can't open the input file print an error message and
  653.          terminate. */
  654.  
  655.    while ((line = fgetline(ifile)) != NULL)
  656.       /* Read the file, line by line, until we get to the end. */
  657.    {
  658.       switch (mode)
  659.       {
  660.       case NEUTRAL:
  661.          if (textlen < (linelen = strlen(line)))
  662.             /* If the line is longer than the text buffer we already have
  663.                let's get a new one. */
  664.          {
  665.             if (text != NULL)
  666.                free(text);
  667.                   /* If we had a text buffer allocated we must free it
  668.                      before we allocate another one. */
  669.             if ((text = malloc(linelen)) == NULL)
  670.                /* If we couldn't allocate memory for the token text print an
  671.                   error message and terminate. */
  672.                fatal("Sh: Couldn't allocate buffer for token text.");
  673.             textlen = linelen;
  674.                /* Remember the new text buffer length. */
  675.          }
  676.          token = parse(line, text);
  677.             /* Break the line down into tokens. */
  678.          switch (token->type)
  679.          {
  680.          case T_CAT:
  681.             while (token->next != NULL)
  682.             {
  683.                token = token->next;
  684.                switch (token->type)
  685.                {
  686.                case T_GT:
  687.                   state = T_GT;
  688.                   continue;
  689.                case T_LTLT:
  690.                   state = T_LTLT;
  691.                   continue;
  692.                case T_WORD:
  693.                   switch (state)
  694.                   {
  695.                   case T_GT:
  696.                      if ((ofile = fopen(token->text, "w")) == NULL)
  697.                      {
  698.                         sprintf(errmsg, "Sh: Can't open %s.", token->text);
  699.                         fatal(errmsg);
  700.                      }
  701.                      state = T_WORD;
  702.                      continue;
  703.                   case T_LTLT:
  704.                      strcpy(ehd, token->text);
  705.                      ehdl = strlen(ehd);
  706.                      mode = COPY;
  707.                      state = T_WORD;
  708.                      continue;
  709.                   }
  710.                }
  711.             }
  712.             continue;
  713.          case T_ECHO:
  714.             while (token->next != NULL)
  715.             {
  716.                token = token->next;
  717.                printf("%s ", token->text);
  718.             }
  719.             printf("\n");
  720.             continue;
  721.          }
  722.          continue;
  723.       case COPY:
  724.          if (strncmp(line, ehd, ehdl) == 0)
  725.             /* This line marks the "here document" end. */
  726.          {
  727.             mode = NEUTRAL;
  728.             fclose(ofile);
  729.             continue;
  730.          }
  731.          fprintf(ofile, "%s", line);
  732.          continue;
  733.       }
  734.    }
  735.    parse(NULL, NULL);
  736.    return(0);
  737. }
  738. SHAR_EOF
  739. cat << \SHAR_EOF > Sh.doc
  740.  
  741.  
  742.  
  743.  
  744.  
  745.  
  746.                         Sh: Unpack Files from Shell Archive
  747.                                         by
  748.                                Fabbian G. Dufoe, III
  749.  
  750.  
  751.  
  752.           INTRODUCTION
  753.  
  754.                Sh is a program designed to unpack shell archives created
  755.           with my Shar program.  It works by recognizing the "cat" and
  756.           "echo" commands and by correctly processing quoted strings, >
  757.           (standard output redirection), and << ("here document"
  758.           redirection).  It does not rely on the existence of any external
  759.           programs.
  760.  
  761.                The shell archive is a technique which makes it easier to
  762.           manipulate collections of related files.  To create a shell
  763.           archive file two or more files are concatenated into a single
  764.           file.  Shell commands are interspersed with the original files.
  765.           That is called packing.  When a command processor reads the shell
  766.           archive file the shell commands cause it to create the original
  767.           files.  That is called unpacking.
  768.  
  769.                The simplest program to pack a shell archive might work by
  770.           prefixing the file with "cat > file <<string" where "file" is the
  771.           name of the file and "string" is a character string which won't
  772.           occur in the file itself.  Next the program copies the text of the
  773.           file.  Finally, it writes a line beginning with "string".
  774.  
  775.                A nicer version would write "echo Creating file" before the
  776.           "cat" command.  Then the shell will report on its progress as it
  777.           unpacks the files.  that is how my Shar program works.  A lot of
  778.           programs pack shell archives essentially the same way but include
  779.           other commands to provide additional enhancements.  Because Sh
  780.           ignores any commands except "echo" and "cat" it will handle those
  781.           files correctly, although it does not support the added features.
  782.           it will not handle files which rely on commands like "sed" for
  783.           unpacking.
  784.  
  785.  
  786.           EXECUTION
  787.  
  788.                To run Sh type "Sh file" where "file" is the name of the
  789.           shell archive file to be unpacked.  If the shell archive file is
  790.           not in the current directory it can be located by either a
  791.           relative or absolute path name.  The unpacked files will be
  792.           located relative to the current directory unless they have
  793.           absolute path names.  There are no command line options.
  794.  
  795.  
  796.           SUMMARY OF EXECUTION
  797.  
  798.                Sh reads the shell archive file until it encounters a line
  799.           beginning with "echo" or "cat".  If the line begins with "echo" Sh
  800.  
  801.  
  802.  
  803.  
  804.  
  805.  
  806.  
  807.  
  808.  
  809.  
  810.  
  811.  
  812.           writes the rest of the line to standard output.
  813.  
  814.                If the line begins with "cat" the processing is more
  815.           complicated.  The program checks for ">" or "<<".  If it finds ">"
  816.           it uses the following word as a file name to open for writing.  If
  817.           it finds "<<" it remembers the following string as a terminator.
  818.  
  819.                Once the "cat" command line has been parsed Sh goes into
  820.           "copy" mode.  It reads a line from the file.  If the line doesn't
  821.           match the terminator string Sh writes it to the output file.  When
  822.           the terminator string is encountered it closes the output file and
  823.           leave "copy" mode.
  824.  
  825.                When Sh encounters end of file it closes its input file and
  826.           terminates.
  827. SHAR_EOF
  828. cat << \SHAR_EOF > Sh.lnk
  829. >FROM LIB:c.o+Sh.o+Fatal.o+Fgetline.o+Gettoken.o+Parse.o
  830. TO Sh
  831. LIB LIB:lc.lib+LIB:amiga.lib
  832. MAP ram:Sh.map
  833. NODEBUG
  834. VERBOSE
  835. SHAR_EOF
  836. cat << \SHAR_EOF > Sh.uu
  837.  
  838. begin 644 Sh
  839. M```#\P`````````"``````````$```I8```!AP```^D```I8)$@D`$GY````#
  840. M`$?Y```#H'(`(#P```"?8`(FP5'(__PL>``$*4X#V"E/`^!"K`/<)FX!%'``H
  841. M(CP``#``3J[^SBEK`)@#U$JK`*QG``!P(`^0KP`$!H````"`*4`#I&$``2X@)
  842. M:P"LT<C1R")H`!#3R=/)(`)R`!(9*4D#Z-"!4H!"9U*``D#__I_`58!"=P@`)
  843. M(`)3@-2!'[(``"``4X)1R/_V'[P`("``4X(?L2``(`!1RO_X(D\O"6```'@I:
  844. M:P`Z`Z1P?U*`T:P#I&$``,)!ZP!<3J[^@$'K`%Q.KOZ,*4`#W"\`)$`@*@`DM
  845. M9Q(L;`88($`B*```*4$#U$ZN_X(B*@`@9QHD/````^U.KO_B*4`#Y&<*Y8@@_
  846. M0"=H``@`I"!L`]PO"$AL`Z`@:``D*6@`!`/H3KH'+$ZZ#B!P`&`$("\`!"\`G
  847. M("P#S&<$($!.D$ZZ'20L>``$(FP&&$ZN_F).N@<"2JP#W&<:(BP#Y&<$3J[__
  848. MW"QX``1.KO]\(FP#W$ZN_H8@'RYL`^!.=7!D8+1#^@`0<`!.KOW8*4`&&&?LW
  849. M3G5D;W,N;&EB<F%R>0!.5?SD2.</,"XO`SPF;P-`>@"5RG@`<`*^@&8*(&L`-
  850. M!'`_L!!F"DAL``!.N@',6$](;``0+RL`!$ZZ'T)03R]``!A*@&8``8`O*P`$3
  851. M2&P`$DAM_.Q.NAE42&W\[$ZZ`9I/[P`08``!8"`%#(`````!9P`!'DJ`9@`!0
  852. M3B\+3KH7SEA/+@"XAVPF(`IG""\*3KH>2%A/+P=.NAQ@6$\D0$J`9@I(;``PE
  853. M3KH!4%A/*`<O"B\+3KD```<,4$\F0"`3#(`````!9P``MDJ`9P``DF```/8@7
  854. M2R9((!`,@`````5G&`R``````V<,#(`````"9FY\`F!J?`-@9B`&#(`````#?
  855. M9SP,@`````)F5$AL`%XO*P`$3KH>:%!/*T#\Z&8<+RL`!$AL`&!(;?SL3KH8(
  856. M?DAM_.Q.N@#$3^\`$'P%8"`O*P`$2&W]\$ZZ%QA(;?WP3KH6_$_O``QZ`7P%O
  857. M*T#]["9K``@@"V8`_VQ@7"!+)D@O*``$2&P`=$ZZ!HQ03R9K``@@"V;F2&P`^
  858. M>$ZZ!@Y83V`V+RW][$AM_?`O"TZZ%@A/[P`,2H!F#GH`+RW\Z$ZZ'^983V`2`
  859. M+PM(;`!Z+RW\Z$ZZ'7Q/[P`,+R\`&$ZY```#]%A/)D!*@&8`_I!P`"\`+P!.N
  860. MN0``!PQ"ETZZ(`9,[0SP_,Q.74YU``!.50``+RT`"$AL`(!(;`&,3KH=,D_O/
  861. M``P@+`842H!O)+"L`;1L'N6`0>P!N"\P"``O+`842&P`A$AL`8Q.NAT&3^\`S
  862. M$"\L!A1.NA^N3EU.=4CG`S`F;P`42JP`E&86+RP`D$ZZ&IQ83RE``)1F!G``"
  863. M8```I'X`8$8@!B!L`)01@'@`<O;2K`"0OH%O,'*`Y8G2K`"0+P$O"$ZZ!"90B
  864. M3R1`(`IF#"!L`)1",'@!(`A@9@:L```"``"0*4H`E%*'+PM.NAZ&6$\L`'#_4
  865. MO(!G!G`*O(!FI'`*O(!F$"!'4H<@!B)L`)0B"!.`&`!P_[R`9AQ*AV88+RP`)
  866. ME$ZZ&^983Y'(*4@&%"E(`)1P`&`*(&P`E$(P>``@"$S?#,!.=4Y5__!(YP<PK
  867. M)F\`+'X`?`%@``(4(`8,@`````5D``((Y8!.^P@"8```R&````Y@``#J8``!0
  868. M)F```6(D;0`,(`5R0`1!``AK``"6L+L0"&;R3OL0!@```%Q@``!H````(F``+
  869. M`%H````G8```3`````E@``&T````"F```:P````@8``!I````#Q@```:````]
  870. M/F````(@!16`>`!",G@!<`)@``&@?``@1U*'(`4B"!6`&`!@``%R?`)@``%L(
  871. M?`-@``%F?`0@;`"84JP`F")'4H<@""()%;,(`!@`8``!2GP$($=2AR`%(@@5,
  872. M@!@`8``!."!M``S1QR1(<#RZ@&80(`44@'(`%4$``7`#8``!-D(24ZP`F'`%6
  873. M8``!*B!M``S1QR1((`4,@````"=G'`R`````7&8<4H<@;`"84JP`F"`(%+,(W
  874. M`&```.!"$G`%8```]%*'(`44@&```,X@;0`,T<<D2"`%#(`````B9QP,@```<
  875. M`%QF'%*'(&P`F%*L`)@@"!2S"`!@``"@0A)P!6```+12AR`%%(!@``".(&T`2
  876. M#-'')$@@!7(P!$$`"&MTL+L0"&;T3OL0!@```")@```J````/F```"(````\G
  877. M8```&@````I@```2````"6````H````@8````E.L`)A"$B!M``Q#[`"<$!BP2
  878. M&68*2@!F]F8$<`!@/B!M``Q#[`"@$!BP&68*2@!F]F8$<`%@)G`%8")2AR`%L
  879. M%(`@;`"84JP`F"`(&C,(`$B%2,5F`/W:0JP`F'`$3-\,X$Y=3G4``$Y5__1(_
  880. MYP$R)F\`*$JM``AF#B\L`*AA``$:<`!@``$*2JP`J&8D2'@`#$ZZ%VQ83RE`S
  881. M`*A*@&8*2&P`K$ZZ_%I83R!L`*A"J``()&P`J"5+``0@;0`(2AAF_%.(D>T`+
  882. M""\(3KH7-%A/)D`@2R](`!`@"&9T2&P`V$ZZ_!Y83V!H)(<@2R9O`!`B2Q#9!
  883. M9OQ*J@`(9C)(>``,3KH6_EA/)4``"$J`9A@O"TZZ&,XNK`"H80``@$AL`/Y.%
  884. MNOO>4$\@:@`(0J@`""!J``@B2TH99OQ3B9/+(`DL:@`$W<!#[@`!(4D`!"1J"
  885. M``@O"R\M``A.N0``!,!03RX`)FH`!'`$OH!F`/]^)(="$TJJ``AG#B\J``AA:
  886. M```>6$]"J@`(+R\`$$ZZ&%8@+`"H3.U,@/_D3EU.=2\+)F\`"$JK``AG""\K$
  887. M``AA[EA/+PM.NA@N6$\F7TYU``!.=4YU2.<#,"9O`!0N+P`82H=F"B\+3KH86
  888. M#%A/8%`@"V8*+P=.NA8>6$]@0B1+68HL$EF&M>P&!&<(0J=.NA8&6$\O!TZZT
  889. M%?Y83R1`2H!G'+R'8P(L!R`&($LB2F`"$MA3@&3Z+PM.NA>\6$\@"DS?#,!.K
  890. M=0```````'!A2.<',"XO`!@F;P`<+"\`("\'3KH?K%A/)$`@"F8$</]@-@@JL
  891. M``,``V<02'@``D*G+P=.NA7D3^\`#"\&+PLO*@`$3KH:T$_O``PJ`$JL`[AGS
  892. M!'#_8`(@!4S?#.!.=0``````````<&%(YP,0)F\`$"!+2AAF_%.(D<LL"'X`D
  893. M'AM*AV<R4ZP!=FT6(&P!;D/H``$I20%N(`<0@'(`$@!@W"`'<@`2`$AL`6HO4
  894. M`4ZZ"#Y03R(`8,9(;`%J2'C__TZZ""Q03R`&3-\(P$YU````````<&%.5?_<9
  895. M2.</,"9O`$1\`$'M``PK2/_R'AM*!V<``0IP);X`9@``S!X;<``0!W(874%KU
  896. M``"(L'L0"&;T3OL0!`!D8```4`!X8```&@!P8```%`!S8````B!M__(D6"M(N
  897. M__)@2B!M__(H&"M(__)%[?_L>@=*A6L6(`1R#\"!0?H`P-'`%)!3BNB$4X5@"
  898. MYD(M_^U@&B!M__(H&"M(__(O!$AM_^5.NA!D4$]%[?_E+PI.NO[D6$_<@&``@
  899. M_UY2AE.L`79M&"!L`6Y#Z``!*4D!;B`'$(!R`!(`8`#_/G``$`=(;`%J+P!.S
  900. MN@<R4$\B`&``_RA2AE.L`79M&"!L`6Y#Z``!*4D!;B`'$(!R`!(`8`#_"'``H
  901. M$`=(;`%J+P!.N@;\4$\B`&``_O)(;`%J2'C__TZZ!N@@!DSM#/#_Q$Y=3G4P/
  902. M,3(S-#4V-S@Y04-$148```!.5?_$2.<G,"9O`%PD;P!@?@!\`'H`<``;?``@;
  903. M__MR`"M!__9T_RM"__)![?_0&T#_\1M`__PK0?_D*T'_Z"M(_\Q*$V="<``0B
  904. M$W(874%K.+![$`AF]D[[$`0`(V```"``(&```!8`*V````P`+6````)^`6`.F
  905. M?`%@"GH!8`8;?``!__Q2BV"Z$!-R,+`!9@92BQM!__MP*K`39A`@4D/H``0D_
  906. MB2M0__92BV`.2&W_]B\+3KH//%!/U\`0$W(NL`%F)E*+<"JP$V80(%)#Z``$"
  907. M)(DK4/_R4HM@#DAM__(O"TZZ#PY03]?`$!-R;+`!9@H;?``!__%2BV`(<FBP8
  908. M`68"4HL0&W(`$@`;0/_P<#!=0&L``E2R>P`(9O1.^P`$`&-@``(J`'-@``'H$
  909. M`%A@``%^`'A@``%X`'!@``%>`&]@``$,`'5@``#B`&1@```"2BW_\6<,(%)#?
  910. MZ``$)(D@$&`*(%)#Z``$)(D@$"M`_^QL"G(!1*W_["M!_^A*K?_H9P1P+6`*O
  911. `;$AL`C1.NAMP2'C__TZZ'<A/[P`02&W_Z$ZZP
  912. &+RW_\$ZZ&T1(;?_H3KHB_"Z`2&P!!"\M__!.H
  913. `*'H"NH=L'"`%Y8`O,P@`2&P!+B\M__!.NAL$0
  914. %Y8!(;`$V+S,(`$ZZ&R103R1`(`IF3"`%Y8`O[
  915. `#"`L!\A*@&\``3*PK`)H;``!*N6`0>P";"\P)
  916. 83^\`$&```0@@!>6`+S,(`$AL`68O+?_P3KH::
  917. O+?_P3KH:9$_O`!A3J@`(;1(@:@`$0^@``25)0
  918. `</^\@&<``)`@;?_P4Z@`#&T6(F@`!$WI``$A.
  919. M_\Q.N@R<4$\K0/_(<%BP+?_P9@#^ODAM_]!.N@L$6$]@`/ZP(%)#Z``$)(DB"
  920. M4"M)_\QF"$'Z`-PK2/_,(&W_S$H89OQ3B)'M_\PK2/_D("W_\DJ`:RJQP&\F+
  921. M*T#_Y&`@<`$K0/_D(%)#Z``$)(D@$!M`_]!"+?_18`9P`&```(P@+?_D(BW_T
  922. M]K*`;`AT`"M"__9@!)&M__9*!V<V4ZW_Y&T8<``@;?_,$!@O`"M(_\P@;0`09
  923. M3I!83V#B4ZW_]FU(<``0+?_[+P`@;0`03I!83V#H4ZW_]FT2<``0+?_[+P`@;
  924. M;0`03I!83V#H4ZW_Y&T8<``@;?_,$!@O`"M(_\P@;0`03I!83V#B(`M,WPSDY
  925. M3EU.=0``3E7_]DCG`3`F;P`>)&\`(BMM`!#_]AX:2@=G-'`EO@!F(K`29@12H
  926. MBF`:+PM(;?_V+PIA`/O,3^\`#"M`__IG!"1`8-)P`!`'+P!.DUA/8,9,WPR`3
  927. M3EU.=4Y5__!(YR$R)F\`+`RL````(`5F;```AA`3<B"P`6<,<@FP`6<&<@JP6
  928. M`68$4HM@Z$H39V@@+`5FY8!2K`5F0>P%;M'`)$AP(K`39B92BR2+2A-G"G`BK
  929. ML!-G!%*+8/)*$V8,2'@``4ZZ!BQ83V">0AM@FB2+2A-G&!`3<B"P`6<0<@FPV
  930. M`6<*<@JP`6<$4HM@Y$H39@)@!D(;8`#_<DJL!69F!B!L`]Q@!$'L!6XI2`5J@
  931. M2JP%9F9\0?H!)$/L!2PBV"+8(M@BV#*0(FP#W"!I`"1(>``H+R@`!$AL!2Q.]
  932. MN@EJ3^\`#$'L!2PB""0\```#[BQL!AA.KO_B*4`#\"E``_AR!"E!`_0I0`0`G
  933. M*4$#_.6`D\DL>``$*T#_\$ZN_MH@;?_P(D`C:``(`*1^`"M`__1@*BQL!AA._
  934. MKO_**4`#\$ZN_\0I0`/X0?H`IB(()#P```/M3J[_XBE`!`!^!"`'`$"``8&LR
  935. M`^P@!P!`@`*!K`/T`*P``(`#`_Q*K`&P9P1P`&`&(#P``(``+@!"K`%D(`<`6
  936. M0``!*4`!8'`!*4`!AB`'`$```BE``8)P`BE``:@@!P!``(`I0`&D0?H6"BE(&
  937. M`]`O+`5J+RP%9DZZ\(I"ETZZ$G1,[4R$_]Q.74YU8V]N.C$P+S$P+S,R,"\XT
  938. M,"\`*@````````````````````````````````````````!P82\+)F\`"$JKF
  939. M`!1G#`@K``,`&V8$<`!@-B\L`YQ.N@[J6$\G0``$)T``$$J`9@IP#"E`!A1PT
  940. M_V`6)VP#G``4<//!JP`8<``G0``,)T``""9?3G4``````````````````$Y5?
  941. M_^Q(YR\0+B\`-"9O`#@H!W`QP*L`&&<&</]@``)P""L`!P`:5L!$`$B`2,`LB
  942. M`$JK`!1F``"$""L``@`;9GIP`"=```QR_[Z!9P`"0B\+3KK_3EA/2H!G#`CK'
  943. M``4`&W#_8``"*@CK``$`&TH&9PX@*P`4(@!$@2=!``Q@""`K`!0G0``,4ZL`A
  944. M#&T6(&L`!$/H``$G20`$(`<0@'(`$@!@$B`'<@`2`"\++P%A`/]24$\B`"`!4
  945. M8``!U@@K``(`&V=8</^^@&8&<`!@``'"(`<;0/__2@9G(G(*OH%F''("+P%(T
  946. M>@&R+RL`'"M!__!.NO8D3^\`#"H`8!IR`2\!2&W__R\K`!PK0?_P3KKV"$_OY
  947. M``PJ`'[_8```X`CK``$`&TH&9U)P_[Z`9TQ4JP`,<@J^@68F(&L`!$/H``$G?
  948. M20`$$+P`#2(K``Q*@6L*+PLO`&$`_JY03U*K``P@:P`$0^@``2=)``0@!Q"`#
  949. M(BL`#$J!:P`!''[_("L`!)"K`!`K0/_P9W((*P`&`!IG4DAX``)"IR\K`!Q.Q
  950. MN@N43^\`#"M`_^Q*!F<X4ZW_[&TR0J<O+?_L+RL`'$ZZ"W1(>``!2&W__2\KK
  951. M`!Q.N@D43^\`&$JL`[AF"A`M__UR&K`!9\@O+?_P+RL`$"\K`!Q.NO4H3^\`K
  952. M#"H`8`)Z`'#_NH!F"`CK``4`&V`,NJW_\&<&".L`!``;2@9G#B(K`!0D`42".
  953. M)T(`#&`8""L``@`;9PAR`"=!``Q@""(K`!0G00`,(&L`$"=(``2^@&<N4ZL`N
  954. M#&T6(&L`!$/H``$G20`$(`<0@'(`$@!@$B`'<@`2`"\++P%A`/V04$\B`'`P/
  955. MP*L`&&<$</]@#'#_N(!F!'``8`(@!$S?"/1.74YU#0H`````2.<'$"9O`!0(S
  956. M*P`'`!I6P$0`2(!(P"X`<##`JP`89PI"JP`(</]@``%8""L`!P`;9Q0(*P`&>
  957. M`!MG#"\+2'C__TZZ_2)03TJK`!1F-D*K``@(*P`"`!MG$G`!)T``%$'K`"`G.
  958. M2``08```A"\+3KK\EEA/2H!G=@CK``4`&W#_8``!`$H'9V94JP`(("L`"$J`#
  959. M;EH@:P`$0^@``2=)``1\`!P0(`8,@````!IG+@R`````#68R4ZL`"&T4(&L`#
  960. M!$/H``$G20`$<``0$&```+0O"V$`_RY83V```*@(ZP`$`!MP_V```)P@!F``"
  961. M`)8(*P`!`!MF3@CK````&R\K`!0O*P`0+RL`'$ZZ!SA/[P`,*@!*A6H&".L`B
  962. M!0`;2H5F!@CK``0`&TJ%;QI*!V<*(`5$@"=```A@!"=%``@@:P`0)T@`!'`RG
  963. MP*L`&&<62@=G"'#_)T``"&`&<``G0``(</]@(%.K``AM$B!K``1#Z``!)TD`"
  964. M!'``$!!@""\+80#^A%A/3-\(X$YU``!(YP<`+B\`$"PL`2Q*1FLP(`9(P.>`^
  965. M0>P#["HP"`!*!6<:"`4``F84(`9(P.>`0>P#["\P"`1.N@_T6$]31F#,+P=.N
  966. MNNL.6$],WP#@3G4``````````'!A56YK;F]W;B!E<G)O<B!C;V1E``!5<V5R-
  967. M(&ES(&YO="!O=VYE<@!.;R!S=6-H(&9I;&4@;W(@9&ER96-T;W)Y`$YO('-U#
  968. M8V@@<')O8V5S<P!);G1E<G)U<'1E9"!S>7-T96T@8V%L;`!)+T\@97)R;W(`2
  969. M3F\@<W5C:"!D979I8V4@;W(@861D<F5S<P!!<F<@;&ES="!I<R!T;V\@;&]NT
  970. M9P``17AE8R!F;W)M870@97)R;W(`0F%D(&9I;&4@;G5M8F5R`$YO(&-H:6QDP
  971. M('!R;V-E<W,``$YO(&UO<F4@<')O8V5S<V5S(&%L;&]W960`3F\@;65M;W)YD
  972. M(&%V86EL86)L90!!8V-E<W,@9&5N:65D`$)A9"!A9&1R97-S`$)U;&L@9&5V6
  973. M:6-E(')E<75I<F5D``!297-O=7)C92!I<R!B=7-Y``!&:6QE(&%L<F5A9'D@[
  974. M97AI<W1S`$-R;W-S+61E=FEC92!L:6YK`$YO('-U8V@@9&5V:6-E``!.;W0@&
  975. M82!D:7)E8W1O<GD`27,@82!D:7)E8W1O<GD``$EN=F%L:60@87)G=6UE;G0`2
  976. M`$YO(&UO<F4@9FEL97,@*'5N:71S*2!A;&QO=V5D`$YO(&UO<F4@9FEL97,@2
  977. M*'5N:71S*2!A;&QO=V5D(&9O<B!T:&ES('!R;V-E<W,``$YO="!A('1E<FUI=
  978. M;F%L``!497AT(&9I;&4@:7,@8G5S>0!&:6QE(&ES('1O;R!L87)G90!.;R!SH
  979. M<&%C92!L969T`%-E96L@:7-S=65D('1O('!I<&4`4F5A9"UO;FQY(&9I;&4@U
  980. M<WES=&5M`%1O;R!M86YY(&QI;FMS``!"<F]K96X@<&EP90!-871H(&9U;F-TF
  981. M:6]N(&%R9W5M96YT(&5R<F]R``!-871H(&9U;F-T:6]N(')E<W5L="!I<R!OM
  982. M=70@;V8@<F%N9V4``$CG(#`F;P`0)$M*$F<D<``0$D'L`ID(,``!"`!G"G(`#
  983. M$@!T()*"8`1R`!(`%(%2BF#8(`M,WPP$3G4``````````'!A2.<#,"9O`!0DT
  984. M;P`8+B\`'$J'9R!*$V<<2A)G&'``$!MR`!(:D($L`$J&9P0@!F`:4X=@W$J'+
  985. M9Q!*$V<$<`%@"DH29P1P_V`"<`!,WPS`3G5.5?_X2.<#,"9O`"`D;P`D+B\`A
  986. M*"!*2AAF_%.(D<HL""!+2AAF_%.(D<L@"")+T\`K2?_XO(=C`BP'(`8@2F`"&
  987. M$MA3@&3Z(&W_^$(P:``@"TS?#,!.74YU(&\`!"`(2AAF_%-(D<`@"$YU```@_
  988. M;P`((F\`!"`)$MAF_$YU("\`""!O``1.5?_T(D]R"DZZ#%P&00`P$L%*@&;P+
  989. M(`D0X;_)9OI"$)"/3EU.=0``("\`""!O``1.5?_T(D\B``)!``<&00`P$L'FN
  990. MB&;P(`D0X;_)9OI"$)"/3EU.=0``,#$R,S0U-C<X.6%B8V1E9B`O``@@;P`$+
  991. M0^\`!#(``D$`#Q+[$-SHB&;R(`DB#UB!$.&RB6;Z0A"0@4YU("\`""!O``1.8
  992. M5?_T(D]L!A#\`"U$@'(*3KH+N`9!`#`2P4J`9O`0X;_)9OI"$"`(3EV0KP`$:
  993. M3G4@;P`$(DAR`'``+P(,$``K9P8,$``M9@)22!`8!```,&T2#```"6X,)`'E&
  994. M@=*"TH'2@&#F#!$`+68"1($D'R`(4X`@;P`(((&0B4YU+P<N+P`(4JP%]"`'"
  995. M(&P%\!#`*4@%\"X?3G5.50``2.<`,"9O`!`D;P`40JP%]"E+!?!(;0`0+PI(K
  996. M>O_&3KKSAB!L!?!"$"`L!?1,[0P`__A.74YU3E7_Z$CG`3(N+P`T2H=N!G#_S
  997. M8```TG`(OH!D`BX`(`=6@"X``D?__"1M``@@;0`(T<??K`%`0^P!/"91*TC_2
  998. M\"M)__0@"V<``)`@2R`K``31P"M(_^PB;?_PM\EC$"2+)4<`!"QM__0LBG``D
  999. M8'BWR68:+%,DCB`K``0B`-*')4$`!"QM__0LBG``8%JUR&0(GZP!0'#_8$ZUP
  1000. MR&8L2I-G#B!3L\AC")^L`4!P_V`XWZL`!$J39PZSTV8*("D`!-&K``0FD7``B
  1001. M8!XK2__T*VW_[/_H)E-@`/]N(&W_]""*0I(E1P`$<`!,WTR`3EU.=0``````:
  1002. M````<&%(YP$0)F\`#"XO`!`O!R\+3KK^]E!/3-\(@$YU2.<',"XO`!@F;P`<L
  1003. M+"\`("\'3KH+Y%A/)$`@"F8$</]@'B\&+PLO*@`$3KH'Z$_O``PJ`$JL`[AG#
  1004. M!'#_8`(@!4S?#.!.=0``3E7_YDCG#S`F;P`Z+B\`/D(M__]"K`.X*VP&%/_RL
  1005. M>@.ZK`$L;!(@!>>`0>P#[$JP"`!G!%*%8.@@+`$LL(5F#'`8*4`&%'#_8``!]
  1006. M*B`%YX!![`/LT<`D2$JM`!!G"`@M``(`$V<**WP```/L_^Y@""M\```#[O_NP
  1007. M(#P``(``P*P!1+&'"`<``V<,(`<"0/_\+@``1P`"(`=R`\"!#(`````"9PP,/
  1008. M@`````%G!$J`9@8L!U*&8`QP%BE`!A1P_V```+0@!P*````#`&<``(@(!P`*9
  1009. M9Q8;?``!__\O+?_N+PM.N@=^4$\H`&`\"`<`"6862'@#[2\+3KH'(%!/*`!*$
  1010. MA&H$",<`"0@'``EG&AM\``'__REM__(&%"\M_^XO"TZZ!Z103R@`2BW__V<VI
  1011. M(`=R>-*!P(%*@&<J2H1K)B\$3KH'[$AX`^TO"TZZ!LY/[P`,*`!@#DAX`^TO2
  1012. M"TZZ!KQ03R@`2JP#N&<$</]@""2&)40`!"`%3-\,\$Y=3G4`````````````@
  1013. M``!(YP`R)FP%^"`+9Q0D4R)+("L`""QX``1.KO\N)DI@Z)'(*4@%_"E(!?A,;
  1014. MWTP`3G5(YP$P+B\`$$JL!@1G%B1L!@0O$B\L!@1.NOW*4$^1R"E(!@1*AV8$U
  1015. M<`!@'EB'+P=.N@&:6$\F0$J`9@1P`&`*)$LDAT'K``0@"$S?#(!.=4CG#Q`NI
  1016. M+P`8+"\`'"HO`"`O!TZZ"9183R9`(`MF!'#_8!XO!2\&+RL`!$ZZ!1Q/[P`,;
  1017. M*`!*K`.X9P1P_V`"(`1,WPCP3G4``$CG`3(N+P`4<`S>@"`'<@`L>``$3J[_(
  1018. M.B9`(`MF!'``8#HG1P`(1>P%^"!J``0G2``$D<@FB$J29@(DBTJJ``1G!B)J/
  1019. M``0BBR5+``1*K`$P9@0I2P$P0>L`#"`(3-],@$YU``````````````````!(]
  1020. MYP,P+B\`%$J';@9P`&```*1P"+Z`9`(N`"`'5H`N``)'__Q%[`$\)E(@"V=`U
  1021. M("L`!+"';3*PAV8,(%,DB)^L`4`@"V!N("L`!)"'<@BP@646($O1QR2()$@D]
  1022. MDR5```2?K`%`(`M@3"1+)E-@O"`'(BP"1-"!4X!.N@8R(BP"1$ZZ!@HL`%"&P
  1023. M(`96@"P``D;__"\&3KK^^EA/)D`@"V<2+P8O"TZZ^SXNAV$`_U103V`"<`!,G
  1024. MWPS`3G4``````````'!A+P<N+P`(+P=.NO\R6$\N'TYU```O"R9O``@@"V<0Y
  1025. M0J=.NOX26$\@2UF(*4@&!'``)E].=4CG`2`N+P`,4JP&$"!L!@Q3J``,;18B^
  1026. M:``$1>D``2%*``0@!Q*`<@`2`&`2(`=R`!(`+P@O`4ZZ\.Q03R(`3-\$@$YUB
  1027. M3E4``$CG`#`F;P`0)&\`%$*L!A`I2P8,2&T`$"\*2'K_G$ZZ[?0NBTAX__].A
  1028. MNO"R("P&$$SM#`#_^$Y=3G4``$Y5__A(YP`P1^P!2"`+9PQ*JP`89P8D2R93=
  1029. M8/`@"V8B2'@`(DZZ_R)83R9`2H!F!'``8!PDBW`A<@`@2Q#!4<C__"\++RT`3
  1030. M#"\M``A.N@`.3.T,`/_P3EU.=0``3E7_\$CG#S`F;P`T)&\`.$JJ`!AG""\*P
  1031. M3KH!HEA/*BP!L'X!<``0,W@`#$``8F<*#$``868,>@!@!BH\``"``%*'<BNRO
  1032. M,W@`5\!$`$B`2,`H`'``$!,,0`!W9P``B`Q``')G0@Q``&%F``"^2'@`#"\\R
  1033. M``"!`B\M``A.NOKL3^\`#"P`</^\@&8&<`!@``#02H1G!G!`T(!@`G`"+@``_
  1034. M1T``8```B$J$9P1P`F`"<```0(``2'@`#"\`+RT`"$ZZ^JA/[P`,+`!P_[R`6
  1035. M9@9P`&```(Q*A&<&<$#0@&`"<`$N`&!(2H1G!'`"8`)P`0!`@```0`$``$`"M
  1036. M`$AX``PO`"\M``A.NOIB3^\`#"P`</^\@&8$<`!@1DJ$9P9P0-"`8`)P`BX`A
  1037. M8`1P`&`RD<@E2``0<``E0``4)48`'"5J`!``!"5```PE0``(2H5F!B`\``"`$
  1038. M`"('@H`E00`8(`I,WPSP3EU.=0``+PLF;P`(""L`!@`;9R(O"TAX__].NN[&0
  1039. M4$]![`%(M\AF#DAL`6I(>/__3KKNL%!/4ZL`"&T2(&L`!$/H``$G20`$<``0>
  1040. M$&`(+PM.NO$L6$\F7TYU2.<#,"9O`!0(*P`!`!MG$"\+2'C__TZZ[G!03RX`"
  1041. M8`)^`"`K`!A"@&<42JL`%&<.+RL`%"\K`!!.NOD.4$\O*P`<3KH$T%A/+`!P9
  1042. M_[Z`9P9*AF8"<`!,WPS`3G5(YP,0+B\`$$?L`4@@"V<T""L``@`;9B@(*P`!/
  1043. M`!MG("`K``20JP`0+`!*AF<2+P8O*P`0+RL`'$ZZY09/[P`,)E-@R"\'3KKR4
  1044. M"%A/3-\(P$YU``!(YS<0+B\`'"9O`"`L+P`D2JP#T&<$3KH$U$*L`[@B!R0+=
  1045. M)@8L;`883J[_T"H`</^Z@&8.3J[_?"E``[AP!2E`!A0@!4S?".Q.=0``2.<_\
  1046. M`"XO`!PL+P`@*B\`)$JL`]!G!$ZZ!(A"K`.X(`53@"(')`8F`"QL!AA.KO^^"
  1047. M*`!P_[B`9@Y.KO]\*4`#N'`6*4`&%"`%#(`````"9Q8,@`````%G"$J`9A@@[
  1048. M!F`4(`30AF`.(@=T`'8`+&P&&$ZN_[Y,WP#\3G4``$CG-Q`N+P`<)F\`("PO-
  1049. M`"1*K`/09P1.N@0,0JP#N"(')`LF!BQL!AA.KO_6*@!P_[J`9@Y.KO]\*4`#.
  1050. MN'`%*4`&%"`%3-\([$YU``!(YR,0)F\`%"XO`!A*K`/09P1.N@/$0JP#N"(+0
  1051. M)`<L;`883J[_XBP`2H9F$DZN_WPI0`.X<`(I0`84</]@`B`&3-\(Q$YU``!.!
  1052. M5?_\2.<A$"9O`!A*K`/09P1.N@-\0JP#N"(+=/XL;`883J[_K"X`2H=G"B('6
  1053. M3J[_IG#_8"8B"R0\```#[DZN_^(N`$J'9A).KO]\*4`#N'`"*4`&%'#_8`(@I
  1054. M!TS?"(1.74YU3E7__$CG(1`F;P`82JP#T&<$3KH#&$*L`[@B"W3^+&P&&$ZNH
  1055. M_ZPN`$J'9PPB!TZN_Z8B"TZN_[@B"R0\```#[DZN_^(N`$J'9A).KO]\*4`#\
  1056. MN'`"*4`&%'#_8`(@!TS?"(1.74YU```O!RXO``A*K`/09P1.N@*V(@<L;`88X
  1057. M3J[_W'``+A].=4CG,``D`"8!2$)(0\3!QL#`P=1#2$)"0M""3-\`#$YU2H!J'
  1058. M```>1(!*@6H```Q$@6$``"!$@4YU80``&$2`1(%.=4J!:@``#$2!80``!D2`G
  1059. M3G4O`DA!-`%F```B2$!(04A"-`!G```&A,$P`DA`-`"$P3`"2$(R`B0?3G4O3
  1060. M`W80#$$`@&0```;AF5%##$$(`&0```;IF5E##$$@`&0```;EF55#2D%K```&4
  1061. MXYE30S0`YJA(0D)"YJI(0X#!-@`P`C0#2$'$P9""9```"%-#T(%D_G(`,@-(A
  1062. M0^>X2$#!028?)!].=4Y5_YY(YS,R?@`@;`/H'BC__W!/OH!O`BX`(`=#[?^OE
  1063. M8`(2V%.`9/I"-7BOD\DL>``$3J[^VB9`2JL`K&=,("L`K.6`)$`L*@`X2H9FQ
  1064. M!"PK`*!*AF<T(@9!^@"R)`AV"RQL!AA.KO_0($=2AR`(&[P`"@BO(@9![?^OM
  1065. M)`@F!RQL!AA.KO_0</]@3DJL!@AF$D/Z`(9P`"QX``1.KOW8*4`&"$'M_Z\I;
  1066. M2`)H2'@`/$AX`/IP`"\`+P!(;`*$2&P"<$AL`EQ"ITZZ`4A/[P`@4X!G!'#_M
  1067. M8`)P`$S?3,Q.74YU*BH@57-E<B!!8F]R="!297%U97-T960@*BH``$-/3E1)Q
  1068. M3E5%``!!0D]25``J*BH@0G)E86LZ(`!I;G1U:71I;VXN;&EB<F%R>0``````#
  1069. M`````````````$CG`1`N+P`,+P=.N@`\6$\F0"`+9@1P_V`H""L``@`#9P9P1
  1070. M`":`8!HO*P`$3KK]EEA/<``F@$JL`[AG!'#_8`)P`$S?"(!.=2\'+B\`"'``T
  1071. M*4`#N$J':R*^K`$L;!P@!^>`0>P#[$JP"`!G#B`'YX!![`/LT<`@"&`(<`DIO
  1072. M0`84<``N'TYU``!(YP$"<``B/```,``L>``$3J[^SBX``H<``#``2H=F!'``,
  1073. M8"!*K`/09Q@@;`/03I!*@&8$<`!@#$AX`!1.NNS26$\@!TS?0(!.=6&T3G4`#
  1074. M`$CG,#(L;`8((&\`&")O`!PD;P`@)F\`)"`O`"@B+P`L)"\`,"8O`#1.KOZD5
  1075. M3-],#$YU``````/L````!`````````?\```#>````XX```)@`````@````$`M
  1076. M```,````!@````````/R```#Z@```.A5<V%G93H@4V@@9FEL92X`<@!3:#H@;
  1077. M0V%N)W0@;W!E;B`E<R!F;W(@:6YP=70N``!3:#H@0V]U;&1N)W0@86QL;V-A]
  1078. M=&4@8G5F9F5R(&9O<B!T;VME;B!T97AT+@``=P!3:#H@0V%N)W0@;W!E;B`E^
  1079. M<RX``"5S(``*`"5S`````"5S"@`))60Z("5S"@````````(```````````!C0
  1080. M870`96-H;P``````````4&%R<V4Z($-O=6QD(&YO="!A;&QO8V%T92!4;VME)
  1081. M;B!S=')U8W1U<F4N``!087)S93H@0V]U;&0@;F]T(&%L;&]C871E('=O<F0@+
  1082. M87)R87DN`%!A<G-E.B!#;W5L9"!N;W0@86QL;V-A=&4@5&]K96X@<W1R=6-T5
  1083. M=7)E+@`````````H`````````````````````````````(`````!:@``````-
  1084. M`````````````````````````````````````8P`````````````````````-
  1085. M`````````````````````````````````````````````````````````````
  1086. M`````````(``````(@``%D0``!98```6:@``%H0``!:4```6K```%K8``!;0B
  1087. M```6Y@``%O@``!<(```7&@``%S0``!=(```75@``%V(``!=X```7B@``%YX`/
  1088. M`!>P```7P```%]```!?@```7\@``&!```!A````84```&&(``!AT```8@@``-
  1089. M&)8``!BL```8O```&,@``!CF```$`/__````#@`.````````)_P`````__\`C
  1090. M```$``0``````````````DC__P````0`!````````"@8`````/__````!``$>
  1091. M````````*"(``````"`@("`@("`@("@H*"@H("`@("`@("`@("`@("`@("`@R
  1092. M2!`0$!`0$!`0$!`0$!`0$(2$A(2$A(2$A(00$!`0$!`0@8&!@8&!`0$!`0$!<
  1093. M`0$!`0$!`0$!`0$!`0$0$!`0$!""@H*"@H("`@("`@("`@("`@("`@("`@("@
  1094. M`A`0$!`@("`@("`@("`@*"@H*"@@("`@("`@("`@("`@("`@("!($!`0$!`0R
  1095. M$!`0$!`0$!`0A(2$A(2$A(2$A!`0$!`0$!"!@8&!@8$!`0$!`0$!`0$!`0$![
  1096. M`0$!`0$!`1`0$!`0$(*"@H*"@@("`@("`@("`@("`@("`@("`@("$!`0$"``[
  1097. M``````(````#[````"8````````"D````GP```)4```"0````CP```(X```"Y
  1098. M-````C````(L```"*````B0```(@```"'````A@```(4```"$````@P```((^
  1099. M```"!````@````'\```!^````?0```'P```![````>@```'D```!X````=P`=
  1100. M``'8```!U````=````',```!R````<0```'````!O````;@````#`````0``5
  1101. 2`FP```%J```!2`````````/R7
  1102. ``
  1103. end
  1104. size 11808
  1105. SHAR_EOF
  1106. cat << \SHAR_EOF > Shar.c
  1107. /*   Shar.c
  1108.  
  1109.      Copyright (c) 1987 by Fabbian G. Dufoe, III
  1110.      All rights reserved.
  1111.  
  1112.      Permission is granted to redistribute this program provided the source
  1113.      code is included in the distribution and this copyright notice is
  1114.      unchanged.
  1115.  
  1116.      This program creates a Unix-compatible shell archive in the first file
  1117.      named on the command line.  It packs all the command-line files after
  1118.      the first into that archive.
  1119.  
  1120.      For each file to be included in the archive the program writes
  1121.           echo "Creating filename"
  1122.           cat > filename <<"***EOF filename***"
  1123.      Then it writes a copy of the file and terminates it with
  1124.           ***EOF filename***
  1125.  
  1126. */
  1127.  
  1128. #include <stdio.h>
  1129. #include <time.h>
  1130. #ifdef AMIGA
  1131. #include <error.h>
  1132. #include <exec/types.h>
  1133. #else
  1134. #include <errno.h>
  1135. #include <ctype.h>
  1136. extern int sys_nerr;
  1137. extern char *sys_errlist[];
  1138. #endif
  1139.  
  1140. void
  1141. main(argc, argv)
  1142. int argc;
  1143. char **argv;
  1144. {
  1145.      int c;
  1146.           /* The character or code returned by getc will be stored here. */
  1147.  
  1148.      int i;
  1149.           /* This will be used as a loop counter to point to the command
  1150.              line argument the program is processing. */
  1151.  
  1152.      FILE *in;
  1153.           /* This is the file pointer which will be used to refer to the
  1154.              current input file in the fgetc() and fclose() functions. */
  1155.  
  1156.      FILE *out;
  1157.           /* This is the file pointer which will be used to refer to the
  1158.              output file in the fputc() and fclose() functions. */
  1159.  
  1160.      int r;
  1161.           /* The code returned by putc will be stored here. */
  1162.  
  1163.      long t;
  1164.           /* The current time in seconds returned by the time() function
  1165. e the string with a null and return.  We
  1166. clude the quotation mark in the string. */
  1167. 3 August 1988 */
  1168.  1988 */
  1169.        default: /* 3 August 1988 */
  1170. ugust 1988 */
  1171.      /* This isn't one of the special characters dealt with
  1172.         above, so we just accumulate it into our string. */
  1173.              The program will write an error message to standard error and
  1174.              terminate. */
  1175.      {
  1176.           fprintf(stderr, "Usage: shar outputfile file[s]\n");
  1177.           exit(-1);
  1178.      }
  1179.  
  1180.      if ((out = fopen(argv[1], "r")) == NULL)
  1181.           /* We try to open the file for reading to see if it is there.  If
  1182.              the open fails we check the error number to see why. */
  1183.      {
  1184.           if (errno == ENOENT)
  1185.                /* An error number of ENOENT means the file doesn't exist.
  1186.                   That's what we want, so we'll just open it. */
  1187.  
  1188.           {
  1189.                if ((out = fopen(argv[1], "w")) == NULL)
  1190.                     /* If we couldn't open the file for writing print an
  1191.                        error message and terminate. */
  1192.                {
  1193.                     fprintf(stderr, "Shar: Couldn't open %s for output.\n",
  1194.                             argv[1]);
  1195.                     if (errno > 0 && errno < sys_nerr)
  1196.                          /* If there is an entry in the system error list
  1197.                             for this error, print the reason for the
  1198.                             error. */
  1199.                          fprintf(stderr, "\t%d: %s\n", errno,
  1200.                                  sys_errlist[errno]);
  1201.                     exit(-1);
  1202.                          /* Terminate with a code to indicate the program
  1203.                             did not complete successfully. */
  1204.                }
  1205.           }
  1206.           else
  1207.                /* If the file open failed for any other reason we know it
  1208.                   exists so we want to display the error message and
  1209.                   terminate. */
  1210.           {
  1211.                fprintf(stderr, "Shar: %s already exists.\n", argv[1]);
  1212.                exit(-1);
  1213.           }
  1214.      }
  1215.      else
  1216.           /* If we were able to open the file we want to close it before we
  1217.              print our error message and terminate. */
  1218.      {
  1219.           (void)fclose(out);
  1220.                /* We don't care if fclose fails--we're going to terminate
  1221.                   the program anyway--so we ignore the value it returns by
  1222.                   casting it to a void. */
  1223.           fprintf(stderr, "Shar: %s already exists.\n", argv[1]);
  1224.           exit(-1);
  1225.      }
  1226.  
  1227.      /* If we got this far we succeeded in opening the output file for
  1228.         writing. */
  1229.  
  1230.      time(&t);
  1231.           /* We want to include the current time in the opening comments.
  1232.              This function gets the number of seconds since the system's
  1233.              base date. */
  1234.  
  1235.      /* Write some identifying comments to the beginning of the output
  1236.         file. */
  1237.      fprintf(out,
  1238.         "# This is a shell archive.  Remove anything before this line,\n");
  1239.      fprintf(out,
  1240.         "# then unpack it by saving it in a file and typing \"sh file\"\n");
  1241.      fprintf(out, "# Created %s#\n", ctime(&t));
  1242.      fprintf(out, "# This archive contains:\n");
  1243.  
  1244.      for (i = 2; i < argc; i++)
  1245.           /* Now we are going to list each of the remaining file names in a
  1246.              comment line. */
  1247.           fprintf(out, "#\t\t%s\n", argv[i]);
  1248.  
  1249.      for (i = 2; i < argc; i++)
  1250.           /* Now we are going to copy each of the remaining file names
  1251.              from the command line. */
  1252.      {
  1253.           if ((in = fopen(argv[i], "r")) == NULL)
  1254.                /* Try to open the file for reading.  If the open fails write
  1255.                   an error message. */
  1256.           {
  1257.                fprintf(stderr, "Shar: couldn't open %s for input.\n",
  1258.                        argv[i]);
  1259.                if (errno > 0 && errno < sys_nerr)
  1260.                     /* If there is an entry in the system error list
  1261.                        for this error, print the reason for the
  1262.                        error. */
  1263.                     fprintf(stderr, "\t%d: %s\n", errno,
  1264.                             sys_errlist[errno]);
  1265.           }
  1266.           else
  1267.                /* If the file was opened successfully add it to the output
  1268.                   file. */
  1269.           {
  1270.                fprintf(out, "echo \"Creating %s\"\n", argv[i]);
  1271.                fprintf(out, "cat > %s <<\"***EOF %s***\"\n", argv[i],
  1272.                        argv[i]);
  1273.                while ((c = getc(in)) != EOF)
  1274.                     /* Read the entire input file and copy it to the output
  1275.                        file. */
  1276.                     if ((r = putc(c, out)) != c)
  1277.                          /* If we couldn't write the character successfully
  1278.                             print an error message and terminate. */
  1279.                     {
  1280.                          fprintf(stderr,
  1281.                                  "Shar: couldn't write from %s to %s.\n",
  1282.                                  argv[i], argv[1]);
  1283.                          if (errno > 0 && errno < sys_nerr)
  1284.                               /* If there is an entry in the system error
  1285.                                  list for this error, print the reason for
  1286.                                  the error. */
  1287.                               fprintf(stderr, "\t%d: %s\n", errno,
  1288.                                       sys_errlist[errno]);
  1289.                          exit(-1);
  1290.                     }
  1291.                fprintf(out, "***EOF %s***\n", argv[i]);
  1292.                fclose(in);
  1293.           }
  1294.      }
  1295.      exit(0);
  1296. }
  1297. SHAR_EOF
  1298. cat << \SHAR_EOF > Shar.uu
  1299.  
  1300. begin 644 Shar
  1301. M```#\P`````````"``````````$```GP```!^P```^D```GP)$@D`$GY````E
  1302. M`$?Y```%&'(`(#P```"U8`(FP5'(__PL>``$*4X%4"E/!5A"K`54)FX!%'``F
  1303. M(CP``#``3J[^SBEK`)@%3$JK`*QG``!P(`^0KP`$!H````"`*4`%'&$``2X@]
  1304. M:P"LT<C1R")H`!#3R=/)(`)R`!(9*4D%8-"!4H!"9U*``D#__I_`58!"=P@`#
  1305. M(`)3@-2!'[(``"``4X)1R/_V'[P`("``4X(?L2``(`!1RO_X(D\O"6```'@I:
  1306. M:P`Z!1QP?U*`T:P%'&$``,)!ZP!<3J[^@$'K`%Q.KOZ,*4`%5"\`)$`@*@`D;
  1307. M9Q(L;`?,($`B*```*4$%3$ZN_X(B*@`@9QHD/````^U.KO_B*4`%7&<*Y8@@H
  1308. M0"=H``@`I"!L!50O"$AL!1@@:``D*6@`!`5@3KH#9$ZZ""1P`&`$("\`!"\`'
  1309. M("P%1&<$($!.D$ZZ&#`L>``$(FP'S$ZN_F).N@,Z2JP%5&<:(BP%7&<$3J[_=
  1310. MW"QX``1.KO]\(FP%5$ZN_H8@'RYL!5A.=7!D8+1#^@`0<`!.KOW8*4`'S&?L@
  1311. M3G5D;W,N;&EB<F%R>0!.5?_HO^P%'&4`#I9(YP\R+B\`/"9O`$!P`[Z`;!A(F
  1312. M;```2&P"-$ZZ'#1(>/__3KH>C$_O``Q(;``@+RL`!$ZZ'%Q03RM`__!*@&8`#
  1313. M`(QP`K"L!\AF9$AL`"(O*P`$3KH</%!/*T#_\$J`9@``CB\K``1(;``D2&P"J
  1314. M-$ZZ&^!/[P`,("P'R$J`;R2PK`)H;![E@$'L`FPO,`@`+RP'R$AL`$A(;`(T`
  1315. M3KH;M$_O`!!(>/__3KH>"%A/8$`O*P`$2&P`4DAL`C1.NAN42'C__TZZ'>Q/[
  1316. M[P`08"(O`$ZZ'80NJP`$2&P`;$AL`C1.NAMP2'C__TZZ'<A/[P`02&W_Z$ZZP
  1317. M#G1(;`"&+RW_\$ZZ&U!(;`#&+RW_\$ZZ&T1(;?_H3KHB_"Z`2&P!!"\M__!.H
  1318. MNALN2&P!%"\M__!.NALB3^\`*'H"NH=L'"`%Y8`O,P@`2&P!+B\M__!.NAL$0
  1319. M3^\`#%*%8.!Z`KJ';``!<B`%Y8!(;`$V+S,(`$ZZ&R103R1`(`IF3"`%Y8`O[
  1320. M,P@`2&P!.$AL`C1.NAK(3^\`#"`L!\A*@&\``3*PK`)H;``!*N6`0>P";"\P)
  1321. M"``O+`?(2&P!7$AL`C1.NAJ83^\`$&```0@@!>6`+S,(`$AL`68O+?_P3KH::
  1322. M?"`%Y8`@<P@`+H@O"$AL`7HO+?_P3KH:9$_O`!A3J@`(;1(@:@`$0^@``25)0
  1323. M``1P`!`08`@O"DZZ"J983RP`</^\@&<``)`@;?_P4Z@`#&T6(F@`!$WI``$A.
  1324. M3@`$(`82@'(`$@!@$B`&<@`2`"\(+P%.N@?04$\B`"@!N(9GGB`%Y8`O*P`$%
  1325. M+S,(`$AL`99(;`(T3KH9YD_O`!`@+`?(2H!O)+"L`FAL'N6`0>P";"\P"``O2
  1326. M+`?(2&P!O$AL`C1.NAFZ3^\`$$AX__].NAP.6$]@`/]*(`7E@"\S"`!(;`'&N
  1327. M+RW_\$ZZ&90NBDZZ&Y)/[P`,4H5@`/Z,0J=.NAO>3.U,\/_,3EU.=0``3G5.A
  1328. M=4CG!S`N+P`8)F\`'"PO`"`O!TZZ(9!83R1`(`IF!'#_8#8(*@`#``-G$$AX^
  1329. M``)"IR\'3KH4X$_O``PO!B\++RH`!$ZZ&]Q/[P`,*@!*K`4P9P1P_V`"(`5,^
  1330. MWPS@3G4``````````'!A3E7_Q$CG)S`F;P!<)&\`8'X`?`!Z`'``&WP`(/_[$
  1331. M<@`K0?_V=/\K0O_R0>W_T!M`__$;0/_\*T'_Y"M!_^@K2/_,2A-G0G``$!-RM
  1332. M&%U!:SBP>Q`(9O9.^Q`$`"-@```@`"!@```6`"M@```,`"U@```"?@%@#GP!>
  1333. M8`IZ`6`&&WP``?_\4HM@NA`3<C"P`68&4HL;0?_[<"JP$V80(%)#Z``$)(DKV
  1334. M4/_V4HM@#DAM__8O"TZZ$$103]?`$!-R+K`!9B92BW`JL!-F$"!20^@`!"2)$
  1335. M*U#_\E*+8`Y(;?_R+PM.NA`64$_7P!`3<FRP`68*&WP``?_Q4HM@"')HL`%F;
  1336. M`E*+$!MR`!(`&T#_\'`P74!K``)4LGL`"&;T3OL`!`!C8``"*@!S8``!Z`!8U
  1337. M8``!?@!X8``!>`!P8``!7@!O8``!#`!U8```X@!D8````DHM__%G#"!20^@`O
  1338. M!"2)(!!@"B!20^@`!"2)(!`K0/_L;`IR`42M_^PK0?_H2JW_Z&<$<"U@"DH&7
  1339. M9P1P*V`"<"`;0/_0<``0!B(M_^B"@'``$`6"@&<(4JW_S%*M_^0O+?_L+RW_D
  1340. MS$ZZ#J903RM`_\@@+?_R2H!J!G(!*T'_\B`M_\@B+?_RDH!([0`"_\1O+B!MK
  1341. M_\PB2-/!8`(2V%.`9/IP`!`M__LB+?_$(&W_S&`"$,!3@63Z("W_\BM`_\C1\
  1342. MK?_D0>W_T"M(_\Q*!V<``5`;?``@__M@``%&2BW_\6<,(%)#Z``$)(D@$&`*N
  1343. M(%)#Z``$)(D@$"M`_^Q@`/]B2BW_\6<,(%)#Z``$)(D@$&`*(%)#Z``$)(D@%
  1344. M$"M`_^Q*+?_\9Q(@;?_,$/P`,'(!*T'_Y"M(_\PO`"\M_\Q.N@X`4$\K0/_(B
  1345. M8`#_*!M\`##_^R`M__)*@&H&<`@K0/_R2BW_\6<,(%)#Z``$)(D@$&`*(%)#+
  1346. MZ``$)(D@$"M`_^Q*+?_\9Q8@;?_,$/P`,!#\`'AR`BM!_^0K2/_,+P`O+?_,]
  1347. M3KH-W%!/*T#_R'!8L"W_\&8`_KY(;?_03KH,N%A/8`#^L"!20^@`!"2)(E`KH
  1348. M2?_,9@A!^@#<*TC_S"!M_\Q*&&;\4XB1[?_,*TC_Y"`M__)*@&LJL<!O)BM`[
  1349. M_^1@('`!*T#_Y"!20^@`!"2)(!`;0/_00BW_T6`&<`!@``",("W_Y"(M__:RQ
  1350. M@&P(=``K0O_V8`21K?_V2@=G-E.M_^1M&'``(&W_S!`8+P`K2/_,(&T`$$Z0/
  1351. M6$]@XE.M__9M2'``$"W_^R\`(&T`$$Z06$]@Z%.M__9M$G``$"W_^R\`(&T`J
  1352. M$$Z06$]@Z%.M_^1M&'``(&W_S!`8+P`K2/_,(&T`$$Z06$]@XB`+3-\,Y$Y=W
  1353. M3G4``$Y5__9(YP$P)F\`'B1O`"(K;0`0__8>&DH'9S1P);X`9B*P$F8$4HI@G
  1354. M&B\+2&W_]B\*80#[S$_O``PK0/_Z9P0D0<``0!R\`3I-83V#&3-\,@$Y=4
  1355. M3G5.5?_P2.<A,B9O`"P,K````"`&XFP``(80$W(@L`%G#'()L`%G!G(*L`%F/
  1356. M!%*+8.A*$V=H("P&XN6`4JP&XD'L!NK1P"1(<"*P$V8F4HLDBTH39PIP(K`3^
  1357. M9P12BV#R2A-F#$AX``%.N@8P6$]@GD(;8)HDBTH39Q@0$W(@L`%G$'()L`%G?
  1358. M"G(*L`%G!%*+8.1*$V8"8`9"&V``_W)*K`;B9@8@;`548`1![`;J*4@&YDJL?
  1359. M!N)F?$'Z`21#[`:H(M@BV"+8(M@RD")L!50@:0`D2'@`*"\H``1(;`:H3KH*\
  1360. MSD_O``Q![`:H(@@D/````^XL;`?,3J[_XBE`!6@I0`5P<@0I005L*4`%>"E!+
  1361. M!73E@)/)+'@`!"M`__!.KO[:(&W_\")`(V@`"`"D?@`K0/_T8"HL;`?,3J[_Q
  1362. MRBE`!6A.KO_$*4`%<$'Z`*8B""0\```#[4ZN_^(I0`5X?@0@!P!`@`&!K`5D;
  1363. M(`<`0(`"@:P%;`"L``"``P5T2JP"6&<$<`!@!B`\``"``"X`0JP"#"`'`$``M
  1364. M`2E``@AP`2E``BX@!P!```(I0`(J<`(I0`)0(`<`0`"`*4`"3$'Z&88I2`5(?
  1365. M+RP&YB\L!N).NO:&0I=.NA4\3.U,A/_<3EU.=6-O;CHQ,"\Q,"\S,C`O.#`O'
  1366. M`"H`````````````````````````````````````````````````+PLF;P`(!
  1367. M2JL`%&<,""L``P`;9@1P`&`V+RP$R$ZZ$0)83R=```0G0``02H!F"G`,*4`'N
  1368. MR'#_8!8G;`3(`!1P\\&K`!AP`"=```PG0``()E].=0``````````````````A
  1369. M3E7_[$CG+Q`N+P`T)F\`."@'<#'`JP`89P9P_V```G`(*P`'`!I6P$0`2(!(9
  1370. MP"P`2JL`%&8``(0(*P`"`!MF>G``)T``#'+_OH%G``)"+PM.NO].6$]*@&<,`
  1371. M".L`!0`;</]@``(J".L``0`;2@9G#B`K`!0B`$2!)T$`#&`(("L`%"=```Q3I
  1372. MJP`,;18@:P`$0^@``2=)``0@!Q"`<@`2`&`2(`=R`!(`+PLO`6$`_U)03R(`>
  1373. M(`%@``'6""L``@`;9UAP_[Z`9@9P`&```<(@!QM`__]*!F<B<@J^@68<<@(O,
  1374. M`4AZ`;(O*P`<*T'_\$ZZ]]Q/[P`,*@!@&G(!+P%(;?__+RL`'"M!__!.NO?`V
  1375. M3^\`#"H`?O]@``#@".L``0`;2@9G4G#_OH!G3%2K``QR"KZ!9B8@:P`$0^@`U
  1376. M`2=)``00O``-(BL`#$J!:PHO"R\`80#^KE!/4JL`#"!K``1#Z``!)TD`!"`';
  1377. M$(`B*P`,2H%K``$<?O\@*P`$D*L`$"M`__!G<@@K``8`&F=22'@``D*G+RL`7
  1378. M'$ZZ#$A/[P`,*T#_[$H&9SA3K?_L;3)"IR\M_^PO*P`<3KH,*$AX``%(;?_]E
  1379. M+RL`'$ZZ"AA/[P`82JP%,&8*$"W__7(:L`%GR"\M__`O*P`0+RL`'$ZZ]N!/.
  1380. M[P`,*@!@`GH`</^Z@&8(".L`!0`;8`RZK?_P9P8(ZP`$`!M*!F<.(BL`%"0!W
  1381. M1((G0@`,8!@(*P`"`!MG"'(`)T$`#&`((BL`%"=!``P@:P`0)T@`!+Z`9RY3)
  1382. MJP`,;18@:P`$0^@``2=)``0@!Q"`<@`2`&`2(`=R`!(`+PLO`6$`_9!03R(`:
  1383. M<##`JP`89P1P_V`,</^X@&8$<`!@`B`$3-\(]$Y=3G4-"@````!(YP<0)F\`W
  1384. M%`@K``<`&E;`1`!(@$C`+@!P,,"K`!AG"D*K``AP_V```5@(*P`'`!MG%`@KT
  1385. M``8`&V<,+PM(>/__3KK](E!/2JL`%&8V0JL`"`@K``(`&V<2<`$G0``40>L`-
  1386. M("=(`!!@``"$+PM.NOR66$]*@&=V".L`!0`;</]@``$`2@=G9E2K``@@*P`(`
  1387. M2H!N6B!K``1#Z``!)TD`!'P`'!`@!@R`````&F<N#(`````-9C)3JP`(;10@B
  1388. M:P`$0^@``2=)``1P`!`08```M"\+80#_+EA/8```J`CK``0`&W#_8```G"`&-
  1389. M8```E@@K``$`&V9.".L````;+RL`%"\K`!`O*P`<3KH(/$_O``PJ`$J%:@8(<
  1390. MZP`%`!M*A68&".L`!``;2H5O&DH'9PH@!42`)T``"&`$)T4`""!K`!`G2``$P
  1391. M<#+`JP`89Q9*!V<(</\G0``(8`9P`"=```AP_V`@4ZL`"&T2(&L`!$/H``$G;
  1392. M20`$<``0$&`(+PMA`/Z$6$],WPC@3G4``$CG!P`N+P`0+"P!U$I&:S`@!DC`(
  1393. MYX!![`5D*C`(`$H%9QH(!0`"9A0@!DC`YX!![`5D+S`(!$ZZ$KA83U-&8,PO[
  1394. M!TZZ\0983TS?`.!.=0``````````<&$N;`583KH2LDAY````%$ZZ$`P`````(
  1395. M`````'!A3E7_^"\+)FP&I"`+9@1'^@!\&5,'?!EK``$'?1EK``('?D(L!W]!K
  1396. M[`=\*4@'=$'K``-(;?_X+PA.N@5:4$]6@-?`("W_^"(\```.$$ZZ$P(I0`=P=
  1397. M2A-G'AE3!X`9:P`!!X$9:P`"!X)P`!E`!X-R`2E!!VQ@"$(L!X!"K`=L0>P'&
  1398. M@"E(!W@F7TY=3G5#4U0V````````````````````````````````````````#
  1399. M`````````````$Y5__)(YP<0)F\`)DAM__A.N@MR6$]Z`!`M__DL``8&``I^<
  1400. M`+X&9")P`!`'5(!R!$ZZ$H9*@68(!H4```%N8`8&A0```6U2!V#:?@$0+?_Z5
  1401. MO@!D%'``$`=R`$'L`EL2,`@`VH%2!V#D<``0!E2`<@1.NA)&2H%F#!`M__IR0
  1402. M`K`!8P)2A7``$"W_^U.`VH`@!7(83KH2!"H`<``0+?_\VH`@!7(\3KH1\BH`$
  1403. M<``0+?_]VH`@!7(\3KH1X"H`<``0+?_^VH!.NOZ"VJP'<"`+9P(FA2`%3-\(9
  1404. MX$Y=3G55;FMN;W=N(&5R<F]R(&-O9&4``%5S97(@:7,@;F]T(&]W;F5R`$YO7
  1405. M('-U8V@@9FEL92!O<B!D:7)E8W1O<GD`3F\@<W5C:"!P<F]C97-S`$EN=&5RZ
  1406. M<G5P=&5D('-Y<W1E;2!C86QL`$DO3R!E<G)O<@!.;R!S=6-H(&1E=FEC92!O5
  1407. M<B!A9&1R97-S`$%R9R!L:7-T(&ES('1O;R!L;VYG``!%>&5C(&9O<FUA="!E?
  1408. M<G)O<@!"860@9FEL92!N=6UB97(`3F\@8VAI;&0@<')O8V5S<P``3F\@;6]R@
  1409. M92!P<F]C97-S97,@86QL;W=E9`!.;R!M96UO<GD@879A:6QA8FQE`$%C8V5SZ
  1410. M<R!D96YI960`0F%D(&%D9')E<W,`0G5L:R!D979I8V4@<F5Q=6ER960``%)E?
  1411. M<V]U<F-E(&ES(&)U<WD``$9I;&4@86QR96%D>2!E>&ES=',`0W)O<W,M9&5VH
  1412. M:6-E(&QI;FL`3F\@<W5C:"!D979I8V4``$YO="!A(&1I<F5C=&]R>0!)<R!A#
  1413. M(&1I<F5C=&]R>0``26YV86QI9"!A<F=U;65N=```3F\@;6]R92!F:6QE<R`H*
  1414. M=6YI=',I(&%L;&]W960`3F\@;6]R92!F:6QE<R`H=6YI=',I(&%L;&]W960@S
  1415. M9F]R('1H:7,@<')O8V5S<P``3F]T(&$@=&5R;6EN86P``%1E>'0@9FEL92!I:
  1416. M<R!B=7-Y`$9I;&4@:7,@=&]O(&QA<F=E`$YO('-P86-E(&QE9G0`4V5E:R!IT
  1417. M<W-U960@=&\@<&EP90!296%D+6]N;'D@9FEL92!S>7-T96T`5&]O(&UA;GD@,
  1418. M;&EN:W,``$)R;VME;B!P:7!E`$UA=&@@9G5N8W1I;VX@87)G=6UE;G0@97)R,
  1419. M;W(``$UA=&@@9G5N8W1I;VX@<F5S=6QT(&ES(&]U="!O9B!R86YG90``2.<@5
  1420. M,"9O`!`D2TH29R1P`!`20>P#Q0@P``$(`&<*<@`2`'0@DH)@!'(`$@`4@5**I
  1421. M8-@@"TS?#`1.=0``````````<&%.5?_X2.<#,"9O`"`D;P`D+B\`*"!*2AAF1
  1422. M_%.(D<HL""!+2AAF_%.(D<L@"")+T\`K2?_XO(=C`BP'(`8@2F`"$MA3@&3Z'
  1423. M(&W_^$(P:``@"TS?#,!.74YU("\`""!O``1.5?_T(D]R"DZZ#I@&00`P$L%*=
  1424. M@&;P(`D0X;_)9OI"$)"/3EU.=0``("\`""!O``1.5?_T(D\B``)!``<&00`P+
  1425. M$L'FB&;P(`D0X;_)9OI"$)"/3EU.=0``,#$R,S0U-C<X.6%B8V1E9B`O``@@1
  1426. M;P`$0^\`!#(``D$`#Q+[$-SHB&;R(`DB#UB!$.&RB6;Z0A"0@4YU(&\`!")(0
  1427. M<@!P`"\"#!``*V<&#!``+68"4D@0&`0``#!M$@P```EN#"0!Y8'2@M*!TH!@@
  1428. MY@P1`"UF`D2!)!\@"%.`(&\`"""!D(E.=2\'+B\`"%*L!X@@!R!L!X00P"E(6
  1429. M!X0N'TYU3E4``$CG`#`F;P`0)&\`%$*L!X@I2P>$2&T`$"\*2'K_QDZZ\GX@"
  1430. M;`>$0A`@+`>(3.T,`/_X3EU.=4Y5_^A(YP$R+B\`-$J';@9P_V```-)P"+Z`G
  1431. M9`(N`"`'5H`N``)'__PD;0`((&T`"-''WZP!Z$/L`>0F42M(__`K2?_T(`MGC
  1432. M``"0($L@*P`$T<`K2/_L(FW_\+?)8Q`DBR5'``0L;?_T+(IP`&!XM\EF&BQ32
  1433. M)(X@*P`$(@#2AR5!``0L;?_T+(IP`&!:M<AD")^L`>AP_V!.M<AF+$J39PX@-
  1434. M4[/(8PB?K`'H</]@.-^K``1*DV<.L]-F"B`I``31JP`$)I%P`&`>*TO_]"MM]
  1435. M_^S_Z"938`#_;B!M__0@BD*2)4<`!'``3-],@$Y=3G4``````````'!A2.<!<
  1436. M$"9O``PN+P`0+P<O"TZZ_O903TS?"(!.=4CG!S`N+P`8)F\`'"PO`"`O!TZZD
  1437. M#GQ83R1`(`IF!'#_8!XO!B\++RH`!$ZZ":A/[P`,*@!*K`4P9P1P_V`"(`5,G
  1438. MWPS@3G4``$Y5_^9(YP\P)F\`.BXO`#Y"+?__0JP%,"ML!\C_\GH#NJP!U&P2+
  1439. M(`7G@$'L!61*L`@`9P12A6#H("P!U+"%9@QP&"E`!\AP_V```2H@!>>`0>P%N
  1440. M9-'`)$A*K0`09P@(+0`"`!-G"BM\```#[/_N8`@K?````^[_[B`\``"``,"L*
  1441. M`>RQAP@'``-G#"`'`D#__"X``$<``B`'<@/`@0R``````F<,#(`````!9P1*E
  1442. M@&8&+`=2AF`,<!8I0`?(</]@``"T(`<"@````P!G``"("`<`"F<6&WP``?__K
  1443. M+RW_[B\+3KH)/E!/*`!@/`@'``EF%DAX`^TO"TZZ".!03R@`2H1J!`C'``D(&
  1444. M!P`)9QH;?``!__\I;?_R!\@O+?_N+PM.N@ED4$\H`$HM__]G-B`'<GC2@<"!S
  1445. M2H!G*DJ$:R8O!$ZZ":Q(>`/M+PM.N@B.3^\`#"@`8`Y(>`/M+PM.N@A\4$\H/
  1446. M`$JL!3!G!'#_8`@DAB5$``0@!4S?#/!.74YU````````````````2.<`,B9LQ
  1447. M!XP@"V<4)%,B2R`K``@L>``$3J[_+B9*8.B1R"E(!Y`I2`>,3-],`$YU2.</6
  1448. M$"XO`!@L+P`<*B\`("\'3KH,?%A/)D`@"V8$</]@'B\%+P8O*P`$3KH'+$_O*
  1449. M``PH`$JL!3!G!'#_8`(@!$S?"/!.=0``2.<!,BXO`!1P#-Z`(`=R`"QX``1.A
  1450. MKO\Z)D`@"V8$<`!@.B='``A%[`>,(&H`!"=(``21R":(2I)F`B2+2JH`!&<&&
  1451. M(FH`!"*+)4L`!$JL`=AF!"E+`=A!ZP`,(`A,WTR`3G4`````````````````1
  1452. M`$Y5_^A(YP\0)F\`-"`3(CP``5&`3KH)6BM`__`L`"`3(CP``5&`3KH)2"X!@
  1453. M(`<B/```#A!.N@DZ*``@!R(\```.$$ZZ"2PN`2`'<CQ.N@DB*T#_Z"`'<CQ.B
  1454. MN@D6+@$I1P><*6W_Z`>@*40'I$AM__!A``!,*@`@!02````';"E`![`I;?_P3
  1455. M![@NA4AM__!A``"&*4`'K"`M__!2@"E`!Z@@!EB`<@=.N@C(*4$'M$'L!YP@C
  1456. M"$SM"/#_U$Y=3G5(YP,0)F\`$"X\```'LBP3#(8```%M;QX@!W($3KH(E$J!<
  1457. M9@@$A@```6Y@!@2&```!;5*'8-H,A@```6UF$"`'<@1.N@AN2H%G!%*'?``F:
  1458. MAB`'3-\(P$YU2.<'$"9O`!0N+P`8(`=R!$ZZ"$A*@68&<!TI0`,`>@`L$W`,A
  1459. MNH!L'"`%Y8!![`+\(C`(`+*&;@Q![`+\G+`(`%*%8-XFAB`%3-\(X$YU2.<#P
  1460. M,"XO`!1*AVX&<`!@``"D<`B^@&0"+@`@!U:`+@`"1__\1>P!Y"92(`MG0"`K^
  1461. M``2PAVTRL(=F#"!3)(B?K`'H(`M@;B`K``20AW((L(%E%B!+T<<DB"1()),E2
  1462. M0``$GZP!Z"`+8$PD2R938+P@!R(L`OC0@5.`3KH'DB(L`OA.N@=J+`!0AB`&P
  1463. M5H`L``)&__PO!DZZ_9983R9`(`MG$B\&+PM.NOHJ+H=A`/]44$]@`G``3-\,R
  1464. MP$YU``````````!P82\'+B\`""\'3KK_,EA/+A].=0``3E7_X$CG+Q`F;P!`:
  1465. M0>W_]"((+&P'S$ZN_T`@+?_T+CP```>Z+``K0/_P#(8```%M;QX@!W($3KH&:
  1466. M_$J!9@@$A@```6Y@!@2&```!;5*'8-H,A@```6UF$"`'<@1.N@;62H%G!%*'E
  1467. M?``@!B('!($```>\%T$``70`%`$K0/_P(`)R!$ZZ!K!*@68$<!U@`G`<&4`#Q
  1468. M+7@`*BW_\'`,N(!L'G``0>P#+!`P2`"PA6X0<`!![`,L$#!(`)J`4H1@W"`%5
  1469. M(@12@1=!``(K0/_P4H`70``#("W_]'('3KH&6A:!("W_^'(\3KH&3A=```0@:
  1470. M+?_X<CQ.N@9`%T$`!2`M__QR,DZZ!C(70``&("W__'(R3KH&)-*!%T$`!TS?!
  1471. M"/1.74YU2.<!("XO``Q2K`?$(&P'P%.H``QM%B)H``1%Z0`!(4H`!"`'$H!R@
  1472. M`!(`8!(@!W(`$@`O""\!3KKMU%!/(@!,WP2`3G5.50``2.<`,"9O`!`D;P`4@
  1473. M0JP'Q"E+!\!(;0`0+PI(>O^<3KKJV"Z+2'C__TZZ[9H@+`?$3.T,`/_X3EU.K
  1474. M=0``3E7_^$CG`#!'[`'P(`MG#$JK`!AG!B1+)E-@\"`+9B)(>``B3KK^(EA/&
  1475. M)D!*@&8$<`!@'"2+<"%R`"!+$,%1R/_\+PLO+0`,+RT`"$ZZ``Y,[0P`__!.F
  1476. M74YU``!.5?_P2.</,"9O`#0D;P`X2JH`&&<(+PI.N@%.6$\J+`)8?@%P`!`S(
  1477. M>``,0`!B9PH,0`!A9@QZ`&`&*CP``(``4H=R*[(S>`!7P$0`2(!(P"@`<``0B
  1478. M$PQ``'=G``"(#$``<F="#$``868``+Y(>``,+SP``($"+RT`"$ZZ^-A/[P`,]
  1479. M+`!P_[R`9@9P`&```-!*A&<&<$#0@&`"<`(N``!'0`!@``"(2H1G!'`"8`)P,
  1480. M``!`@`!(>``,+P`O+0`(3KKXE$_O``PL`'#_O(!F!G``8```C$J$9P9P0-"`7
  1481. M8`)P`2X`8$A*A&<$<`)@`G`!`$"```!``0``0`(`2'@`#"\`+RT`"$ZZ^$Y/F
  1482. M[P`,+`!P_[R`9@1P`&!&2H1G!G!`T(!@`G`"+@!@!'``8#*1R"5(`!!P`"5`@
  1483. M`!0E1@`<)6H`$``$)4``#"5```A*A68&(#P``(``(@>"@"5!`!@@"DS?#/!.[
  1484. M74YU``!(YP,P)F\`%`@K``$`&V<0+PM(>/__3KKKK%!/+@!@`GX`("L`&$*`:
  1485. M9Q1*JP`49PXO*P`4+RL`$$ZZ]TY03R\K`!Q.N@6H6$\L`'#_OH!G!DJ&9@)P]
  1486. M`$S?#,!.=4CG`Q`N+P`01^P!\"`+9S0(*P`"`!MF*`@K``$`&V<@("L`!)"K1
  1487. M`!`L`$J&9Q(O!B\K`!`O*P`<3KKC^D_O``PF4V#(+P=.NN]$6$],WPC`3G4`X
  1488. M`$CG-Q`N+P`<)F\`("PO`"1*K`5(9P1.N@6L0JP%,"(')`LF!BQL!\Q.KO_0G
  1489. M*@!P_[J`9@Y.KO]\*4`%,'`%*4`'R"`%3-\([$YU``!(YS\`+B\`'"PO`"`J<
  1490. M+P`D2JP%2&<$3KH%8$*L!3`@!5.`(@<D!B8`+&P'S$ZN_[XH`'#_N(!F#DZNE
  1491. M_WPI0`4P<!8I0`?((`4,@`````)G%@R``````6<(2H!F&"`&8!0@!-"&8`XBO
  1492. M!W0`=@`L;`?,3J[_ODS?`/Q.=0``2.<W$"XO`!PF;P`@+"\`)$JL!4AG!$ZZ8
  1493. M!.1"K`4P(@<D"R8&+&P'S$ZN_]8J`'#_NH!F#DZN_WPI0`4P<`4I0`?((`5,%
  1494. MWPCL3G4``$CG(Q`F;P`4+B\`&$JL!4AG!$ZZ!)Q"K`4P(@LD!RQL!\Q.KO_BO
  1495. M+`!*AF823J[_?"E`!3!P`BE`!\AP_V`"(`9,WPC$3G4``$Y5__Q(YR$0)F\`W
  1496. M&$JL!4AG!$ZZ!%1"K`4P(@MT_BQL!\Q.KO^L+@!*AV<*(@=.KO^F</]@)B(+6
  1497. M)#P```/N3J[_XBX`2H=F$DZN_WPI0`4P<`(I0`?(</]@`B`'3-\(A$Y=3G5./
  1498. M5?_\2.<A$"9O`!A*K`5(9P1.N@/P0JP%,"(+=/XL;`?,3J[_K"X`2H=G#"('U
  1499. M3J[_IB(+3J[_N"(+)#P```/N3J[_XBX`2H=F$DZN_WPI0`4P<`(I0`?(</]@A
  1500. M`B`'3-\(A$Y=3G4``"\'+B\`"$JL!4AG!$ZZ`XXB!RQL!\Q.KO_<<``N'TYU;
  1501. M3E7_L"\.2JP'F&820_H`B'``+'@`!$ZN_=@I0`>8<``@;`5@$"C__T/M_[!@H
  1502. M`A+84X!D^G``(&P%8!`H__]"-0BP0>W_L"E(`T1(>``H2'@`^G``+P`O`$AL<
  1503. M`V!R`"\!2&P#3"\!3KH#9$AX`!1.NNR`+&W_K$Y=3G4J*B!3=&%C:R!/=F5R'
  1504. M9FQO=R`J*@``15A)5```:6YT=6ET:6]N+FQI8G)A<GD`````````````````L
  1505. M2.<P`"0`)@%(0DA#Q,'&P,#!U$-(0D)"T(),WP`,3G5*@&H``!Y$@$J!:@``'
  1506. M#$2!80``($2!3G5A```81(!$@4YU2H%J```,1(%A```&1(!.=2\"2$$T`68`H
  1507. M`")(0$A!2$(T`&<```:$P3`"2$`T`(3!,`)(0C(")!].=2\#=A`,00"`9```U
  1508. M!N&944,,00@`9```!NF964,,02``9```!N6954-*06L```;CF5-#-`#FJ$A"X
  1509. M0D+FJDA#@,$V`#`"-`-(0<3!D()D```(4T/0@63^<@`R`TA#Y[A(0,%!)A\D8
  1510. M'TYU3E7_GDCG,S)^`"!L!6`>*/__<$^^@&\"+@`@!T/M_Z]@`A+84X!D^D(U^
  1511. M>*^3R2QX``1.KO[:)D!*JP"L9TP@*P"LY8`D0"PJ`#A*AF8$+"L`H$J&9S0B%
  1512. M!D'Z`+(D"'8++&P'S$ZN_]`@1U*'(`@;O``*"*\B!D'M_Z\D""8'+&P'S$ZN:
  1513. M_]!P_V!.2JP'F&820_H`AG``+'@`!$ZN_=@I0`>80>W_KRE(`Y1(>``\2'@`-
  1514. M^G``+P`O`$AL`[!(;`.<2&P#B$*G3KH!;$_O`"!3@&<$</]@`G``3-],S$Y=J
  1515. M3G4J*B!5<V5R($%B;W)T(%)E<75E<W1E9"`J*@``0T].5$E.544``$%"3U)41
  1516. M`"HJ*B!"<F5A:SH@`&EN='5I=&EO;BYL:6)R87)Y````3E7__"\+)F\`$$ZZH
  1517. MZI0@$Y"L!W`K0/_\2&W__$ZZ]((N@$ZZ`1@F;?_X3EU.=0``2.<!$"XO``PO7
  1518. M!TZZ`#Q83R9`(`MF!'#_8"@(*P`"``-G!G``)H!@&B\K``1.NOR^6$]P`":`V
  1519. M2JP%,&<$</]@`G``3-\(@$YU+P<N+P`(<``I0`4P2H=K(KZL`=1L'"`'YX!!J
  1520. M[`5D2K`(`&<.(`?G@$'L!631P"`(8`AP"2E`!\AP`"X?3G4``$CG`0)P`"(\"
  1521. M```P`"QX``1.KO[.+@`"AP``,`!*AV8$<`!@($JL!4AG&"!L!4A.D$J`9@1P/
  1522. M`&`,2'@`%$ZZZ3983R`'3-]`@$YU8;1.=0``2.<P,BQL!Y@@;P`8(F\`'"1OJ
  1523. M`"`F;P`D("\`*"(O`"PD+P`P)B\`-$ZN_J1,WTP,3G4``"\+)F\`""`K`!CE<
  1524. M@"(K`!#E@2\K`!0O$R\K``0O*P`(+RL`#$'L!,PO,!@`0>P$_"\P"`!(>@!D'
  1525. M2&P'T$ZZ[R!/[P`D0>P'T"`()E].=4IA;@!&96(`36%R`$%P<@!-87D`2G5NU
  1526. M`$IU;`!!=6<`4V5P`$]C=`!.;W8`1&5C`%-U;@!-;VX`5'5E`%=E9`!4:'4`T
  1527. M1G)I`%-A=``E<R`E<R`E,#)D("4P,F0Z)3`R9#HE,#)D(#$Y)3`R9`H````#[
  1528. M[`````(````!````#`````8````````#\@```^H```%&57-A9V4Z('-H87(@'
  1529. M;W5T<'5T9FEL92!F:6QE6W-="@!R`'<`4VAA<CH@0V]U;&1N)W0@;W!E;B`EN
  1530. M<R!F;W(@;W5T<'5T+@H`"25D.B`E<PH``%-H87(Z("5S(&%L<F5A9'D@97AI9
  1531. M<W1S+@H`4VAA<CH@)7,@86QR96%D>2!E>&ES=',N"@`C(%1H:7,@:7,@82!SW
  1532. M:&5L;"!A<F-H:79E+B`@4F5M;W9E(&%N>71H:6YG(&)E9F]R92!T:&ES(&QIE
  1533. M;F4L"@``(R!T:&5N('5N<&%C:R!I="!B>2!S879I;F<@:70@:6X@82!F:6QER
  1534. M(&%N9"!T>7!I;F<@(G-H(&9I;&4B"@`C($-R96%T960@)7,C"@``(R!4:&ES2
  1535. M(&%R8VAI=F4@8V]N=&%I;G,Z"@`C"0DE<PH``'(`4VAA<CH@8V]U;&1N)W0@V
  1536. M;W!E;B`E<R!F;W(@:6YP=70N"@``"25D.B`E<PH``&5C:&\@(D-R96%T:6YGU
  1537. M("5S(@H`8V%T(#X@)7,@/#PB*BHJ14]&("5S*BHJ(@H``%-H87(Z(&-O=6QDE
  1538. M;B=T('=R:71E(&9R;VT@)7,@=&\@)7,N"@``"25D.B`E<PH``"HJ*D5/1B`E^
  1539. M<RHJ*@H`````*`````````````````````````````"``````A(`````````W
  1540. M``````````````````````````````````(T````````````````````````V
  1541. M`````````````````````````````````````````````````````````````
  1542. M``````"``!\<'QX?'A\?'A\>'P```"(``!'\```2$```$B(``!(\```23```>
  1543. M$F0``!)N```2B```$IX``!*P```2P```$M(``!+L```3````$PX``!,:```3J
  1544. M,```$T(``!-6```3:```$W@``!.(```3F```$ZH``!/(```3^```%`@``!0:G
  1545. M```4+```%#H``!1.```49```%'0``!2````4G@``!``````?````'````!\`4
  1546. M```>````'P```!X````?````'P```!X````?````'@```!\?'!\>'QX?'QX?#
  1547. M'A___P````X`#@```````````````/__````!``$````````(WX```,X__\`W
  1548. M```$``0````````CE`````#__P````X`#@```````"5\`````/__````!``$`
  1549. M``````````````-T__\````$``0````````EF`````#__P````0`!````````
  1550. M`"6B```````@("`@("`@("`H*"@H*"`@("`@("`@("`@("`@("`@($@0$!`0W
  1551. M$!`0$!`0$!`0$!"$A(2$A(2$A(2$$!`0$!`0$(&!@8&!@0$!`0$!`0$!`0$!9
  1552. M`0$!`0$!`0$!$!`0$!`0@H*"@H*"`@("`@("`@("`@("`@("`@("`@(0$!`0=
  1553. M("`@("`@("`@("@H*"@H("`@("`@("`@("`@("`@("`@2!`0$!`0$!`0$!`0`
  1554. M$!`0$(2$A(2$A(2$A(00$!`0$!`0@8&!@8&!`0$!`0$!`0$!`0$!`0$!`0$!P
  1555. M`0$0$!`0$!""@H*"@H("`@("`@("`@("`@("`@("`@("`A`0$!`@```````"X
  1556. M````)U(``"=6```G6@``)UX``"=B```G9@``)VH``"=N```G<@``)W8``"=Z/
  1557. M```G?@``)X(``">&```GB@``)XX``">2```GE@``)YH```/L````.P``````"
  1558. M``44```%$```!0P```4(```%!```!0````3\```$^```!/0```3P```$[```R
  1559. M!.@```3D```$X```!-P```38```$U```!-````3,```#O````Z@```.````#@
  1560. M;````U@```+T```"\````NP```+H```"Y````N````+<```"V````M0```+0O
  1561. M```"S````L@```+$```"P````KP```*X```"M````K````*L```"J````J0`^
  1562. M``*@```"G````I@```*4```"D````HP```*(```"A````H````)\```">```:
  1563. J`G0```)P```";`````0````!```#F````UP```(2```!\`````````/R/
  1564. ``
  1565. end
  1566. size 11832
  1567. SHAR_EOF
  1568. cat << \SHAR_EOF > Token.h
  1569. typedef enum
  1570. {
  1571.      T_CAT,    /* The token is the "cat" command.  To be a command the token
  1572.                   must be the first one on the line. */
  1573.      T_ECHO,   /* The token is the "echo" command.  It must be the first
  1574.                   token on the line. */
  1575.      T_GT,     /* The token is ">" indicating redirection of standard
  1576.                   output.  It must be preceded by a T_CAT or T_ECHO
  1577.                   token. */
  1578.      T_LTLT,   /* The token is "<<" indicating "here document" redirection.
  1579.                   It must be preceded by a T_CAT or T_ECHO token.  The next
  1580.                   word defines the "here document" terminator.  Subsequent
  1581.                   lines from the input file are treated as input for the
  1582.                   command on this line. */
  1583.      T_NL,     /* The token is a newline character.  It means we have
  1584.                   encountered the end of the text line.  There are no more
  1585.                   tokens to identify. */
  1586.      T_WORD    /* The token is any word not of the above type.  A word is a
  1587.                   string of characters surrounded by white space or enclosed
  1588.                   in double quotation marks. */
  1589. } TOKEN;
  1590.      /* This is a list of recognized token types. */
  1591.  
  1592. struct Token
  1593.      /* This is a linked list of tokens giving type, text, and pointer to
  1594.         the next token. */
  1595. {
  1596.      TOKEN type;
  1597.           /* This is the token type.  It must have one of the values listed
  1598.              under the data type TOKEN. */
  1599.      char *text;
  1600.           /* This is a pointer to a character string containing the actual
  1601.              text of the token. */
  1602.      struct Token *next;
  1603.           /* This is a pointer to the next token structure in the list.
  1604.              When it is NULL there are no more tokens. */
  1605. };
  1606. SHAR_EOF
  1607. #    End of shell archive
  1608. exit 0
  1609. -- 
  1610. Bob Page, U of Lowell CS Dept.  page@swan.ulowell.edu  ulowell!page
  1611. Have five nice days.
  1612.